Refine search
@Override public String toString() { StringBuilder builder = new StringBuilder(); builder.append("IndexResponse["); builder.append("index=").append(getIndex()); builder.append(",type=").append(getType()); builder.append(",id=").append(getId()); builder.append(",version=").append(getVersion()); builder.append(",result=").append(getResult().getLowercase()); builder.append(",seqNo=").append(getSeqNo()); builder.append(",primaryTerm=").append(getPrimaryTerm()); builder.append(",shards=").append(Strings.toString(getShardInfo())); return builder.append("]").toString(); }
IndexResponse r = elasticsearchClient.prepareIndex(indexName, typeName, id).setSource(jsonMap) .setVersion(version == null ? 1 : version.longValue()) .setVersionType(version == null ? VersionType.FORCE : VersionType.EXTERNAL) .execute() .actionGet(); if (version != null) jsonMap.put("_version", version); // to prevent side effects boolean created = r.isCreated(); // true means created, false means updated long duration = Math.max(1, System.currentTimeMillis() - start); long regulator = 0;
@Override protected IndexResponse newResponseInstance() { return new IndexResponse(); } }
@Override public IndexResponse build() { IndexResponse indexResponse = new IndexResponse(shardId, type, id, seqNo, primaryTerm, version, result); indexResponse.setForcedRefresh(forcedRefresh); if (shardInfo != null) { indexResponse.setShardInfo(shardInfo); } return indexResponse; } }
@Override protected void onPersist(EntityMetadata entityMetadata, Object entity, Object id, List<RelationHolder> rlHolders) { try { Map<String, Object> values = new HashMap<String, Object>(); MetamodelImpl metaModel = (MetamodelImpl) kunderaMetadata.getApplicationMetadata() .getMetamodel(entityMetadata.getPersistenceUnit()); EntityType entityType = metaModel.entity(entityMetadata.getEntityClazz()); String keyAsString = getKeyAsString(id, entityMetadata, metaModel); addSource(entity, values, entityType); addRelations(rlHolders, values); addDiscriminator(values, entityType); IndexResponse response = txClient .prepareIndex(entityMetadata.getSchema().toLowerCase(), entityMetadata.getTableName(), keyAsString) .setSource(values).setRefresh(isRefreshIndexes()).execute().actionGet(); assert response.getId() != null; } finally { // Nothing as of now. } }
final String documentType = getTable().getName(); final IndexRequestBuilder requestBuilder = new IndexRequestBuilder(client, IndexAction.INSTANCE).setIndex(indexName).setType(documentType); requestBuilder.setSource(valueMap); final IndexResponse result = requestBuilder.execute().actionGet(); logger.debug("Inserted document: id={}", result.getId()); client.admin().indices().prepareRefresh(indexName).execute().actionGet();
private void createUserID(final long userID) { final GetResponse getResponse = client .prepareGet(userIndex, userType, Long.toString(userID)) .setRefresh(true).execute().actionGet(); if (!getResponse.isExists()) { final Map<String, Object> source = new HashMap<>(); source.put("system_id", Long.toString(userID)); source.put(userIdField, userID); source.put(timestampField, new Date()); final IndexResponse response = client .prepareIndex(userIndex, userType, Long.toString(userID)) .setSource(source).setRefresh(true).execute().actionGet(); if (!response.isCreated()) { throw new TasteException("Failed to create " + source); } } }
IndexResponse indexResponse = client.prepareIndex() .setIndex(pubSubIndexName) .setType(TYPE) .setSource(messageBuilder) .setRefresh(request.paramAsBoolean("refresh", true)) .execute().actionGet(); responseBuilder.field("id", indexResponse.getId()); SearchResponse searchResponse = client.prepareSearch() .setIndices(pubSubIndexName) .setTypes("subscribe") .addField("subscriber.channel") .setSize(100) .execute().actionGet(); boolean failed = searchResponse.getFailedShards() > 0 || searchResponse.isTimedOut(); if (failed) { searchResponse = client.prepareSearchScroll(searchResponse.getScrollId()) .setScroll(new TimeValue(60000)) .execute().actionGet(); for (SearchHit hit : searchResponse.getHits()) {
} while (!liveIds.remove(id)); DeleteResponse response = client.prepareDelete("index", BatchPercolatorService.TYPE_NAME, id) .execute().actionGet(); assertThat(response.getId(), equalTo(id)); assertThat("doc[" + id + "] should have been deleted, but isn't", response.isFound(), equalTo(true)); } else { String id = Integer.toString(idGen.getAndIncrement()); IndexResponse response = client.prepareIndex("index", BatchPercolatorService.TYPE_NAME, id) .setSource(doc) .execute().actionGet(); liveIds.add(id); assertThat(response.isCreated(), equalTo(true)); // We only add new docs assertThat(response.getId(), equalTo(id));
/** * 添加索引 * @throws Exception */ @Test public void testIndex3() throws Exception{ Map<String,Object> json = new HashMap<String,Object>(); json.put("user","kimchy"); json.put("postDate",new Date()); json.put("message","trying out Elasticsearch"); IndexResponse response = client.prepareIndex("qq","tweet") .setSource(json) .get(); System.out.println("索引名称:"+response.getIndex()); System.out.println("类型:"+response.getType()); System.out.println("文档Id:"+response.getId()); System.out.println("当前实例状态:"+response.status()); }
public void index(final Entity entity, final Tenant tenant) throws SearchEngineException { try { Map<String, Object> source = entityIndexDocumentPurveyor.purveyDocument(entity, tenant); if (source.keySet().size() > 0) { String entityName = StringUtils.substringAfterLast(entity.getClass().getName(), ".").toLowerCase(); this.logger.debug("Indexing {} with id {}...", entityName, entity.getId()); IndexRequestBuilder builder = this.client.prepareIndex("entities", entityName, entity.getId().toString()).setSource(source); if (tenant != null && !Tenant.class.isAssignableFrom(entity.getClass())) { builder.setParent(tenant.getId().toString()); } IndexResponse response = builder.execute().actionGet(); this.logger.debug("" + response.getType()); } } catch (Exception e) { throw new SearchEngineException("Failed to index entity", e); } }
@Override public void execute(Tuple tuple) { String id = null; String indexName = null; String type = null; String document = null; try { id = this.tupleMapper.mapToId(tuple); indexName = this.tupleMapper.mapToIndex(tuple); type = this.tupleMapper.mapToType(tuple); document = this.tupleMapper.mapToDocument(tuple); byte[] byteBuffer = document.getBytes(); IndexResponse response = this.client.prepareIndex(indexName, type, id).setSource(byteBuffer).execute() .actionGet(); LOG.debug("Indexed Document[ " + id + "], Type[" + type + "], Index[" + indexName + "], Version [" + response.getVersion() + "]"); collector.ack(tuple); } catch (Exception e) { LOG.error("Unable to index Document[ " + id + "], Type[" + type + "], Index[" + indexName + "]", e); collector.ack(tuple); } }
BulkRequestBuilder bulkRequest = elasticsearchClient.prepareBulk(); for (BulkWriteEntry be: jsonMapList) { if (be.getId() == null) continue; bulkRequest.add( elasticsearchClient.prepareIndex(indexName, be.getType(), be.getId()).setSource(be.getJsonMap()) .setVersion(be.getVersion() == null ? 1 : be.getVersion().longValue()) .setVersionType(be.getVersion() == null ? VersionType.FORCE : VersionType.EXTERNAL)); ActionWriteResponse response = r.getResponse(); if (response instanceof IndexResponse) { if (((IndexResponse) response).isCreated()) result.getCreated().add(id);
BulkRequestBuilder bulkRequest = client.prepareBulk(); for (int i = 0; i < batchSize; i++) { id = idGenerator.incrementAndGet(); if (useAutoGeneratedIDs) { bulkRequest.add(client.prepareIndex(index, type).setSource(generateSource(id, threadRandom))); } else { bulkRequest.add(client.prepareIndex(index, type, Long.toString(id)).setSource(generateSource(id, threadRandom))); IndexResponse indexResponse = client.prepareIndex(index, type).setSource(generateSource(id, threadRandom)).get(); boolean add = ids.add(indexResponse.getId()); assert add : "ID: " + indexResponse.getId() + " already used"; } else { IndexResponse indexResponse = client.prepareIndex(index, type, Long.toString(id)).setSource(generateSource(id, threadRandom)).get(); boolean add = ids.add(indexResponse.getId()); assert add : "ID: " + indexResponse.getId() + " already used";
@Override public Status insert(String table, String key, Map<String, ByteIterator> values) { try (XContentBuilder doc = jsonBuilder()) { doc.startObject(); for (final Entry<String, String> entry : StringByteIterator.getStringMap(values).entrySet()) { doc.field(entry.getKey(), entry.getValue()); } doc.field(KEY, key); doc.endObject(); final IndexResponse indexResponse = client.prepareIndex(indexKey, table).setSource(doc).get(); if (indexResponse.getResult() != DocWriteResponse.Result.CREATED) { return Status.ERROR; } if (!isRefreshNeeded) { synchronized (this) { isRefreshNeeded = true; } } return Status.OK; } catch (final Exception e) { e.printStackTrace(); return Status.ERROR; } }
public void createRecord(Road road, Car car) throws Exception{ ObjectMapper objectMapper = new ObjectMapper(); String roadJson = objectMapper.writeValueAsString(road); String carJson = objectMapper.writeValueAsString(car); Client client = TransportClient.builder().build().addTransportAddress(new InetSocketTransportAddress(InetAddress.getByName("localhost"), 9300)); if(!client.admin().indices().prepareExists("myIndex").get().isExists()){ XContentBuilder xContentBuilder = XContentFactory.jsonBuilder().startObject().startObject("roadType").endObject().endObject(); XContentBuilder xContentBuilder2 = XContentFactory.jsonBuilder().startObject().startObject("carType").startObject("_parent").field("type", "roadType").endObject().endObject().endObject(); client.admin().indices().create(new CreateIndexRequest("myIndex")).get(); client.admin().indices().preparePutMapping("myIndex").setType("carType").setSource(xContentBuilder2).get(); client.admin().indices().preparePutMapping("myIndex").setType("roadType").setSource(xContentBuilder).get(); } IndexResponse response = client.prepareIndex("myIndex", "roadType").setSource(roadJson).get(); client.prepareIndex("myIndex", "carType").setParent(response.getId()).setSource(carJson).get(); }
private boolean insert(String id, Map source) { Preconditions.checkNotNull(source, "source must not be null."); logger.info("insert data : {}", JSON.toJSONString(source)); IndexRequestBuilder builder = client.prepareIndex(index, type).setSource(source); if (StringUtils.isNotBlank(id)) { builder.setId(id); } IndexResponse response = builder.get(); logger.info("insert response : {}", response.toString()); return response.isCreated(); }
@Override public PutIndexedScriptResponse getDelegatedFromInstigator(IndexResponse indexResponse){ return new PutIndexedScriptResponse(indexResponse.getType(),indexResponse.getId(),indexResponse.getVersion(),indexResponse.isCreated()); } });