private ImmutableList<ColumnIdent> getPrimaryKey() {
Map<String, Object> metaMap = getNested(defaultMappingMap, "_meta");
if (metaMap != null) {
ImmutableList.Builder<ColumnIdent> builder = ImmutableList.builder();
Object pKeys = metaMap.get("primary_keys");
if (pKeys != null) {
if (pKeys instanceof String) {
builder.add(ColumnIdent.fromPath((String) pKeys));
return builder.build();
} else if (pKeys instanceof Collection) {
Collection keys = (Collection) pKeys;
if (!keys.isEmpty()) {
for (Object pkey : keys) {
builder.add(ColumnIdent.fromPath(pkey.toString()));
}
return builder.build();
}
}
}
}
if (getCustomRoutingCol() == null && partitionedByList.isEmpty()) {
hasAutoGeneratedPrimaryKey = true;
return ImmutableList.of(ID_IDENT);
}
return ImmutableList.of();
}
private ImmutableList<ColumnIdent> getPartitionedBy() {
ImmutableList.Builder<ColumnIdent> builder = ImmutableList.builder();
for (List<String> partitionedByInfo : partitionedByList) {
builder.add(ColumnIdent.fromPath(partitionedByInfo.get(0)));
}
return builder.build();
}
private ColumnIdent getCustomRoutingCol() {
if (defaultMappingMetaData != null) {
Map<String, Object> metaMap = getNested(defaultMappingMap, "_meta");
if (metaMap != null) {
String routingPath = (String) metaMap.get("routing");
if (routingPath != null && !routingPath.equals(ID)) {
return ColumnIdent.fromPath(routingPath);
}
}
}
return null;
}
private boolean generatedExpressionEvaluationNeeded(
List<ReferenceInfo> referencedReferenceInfos, Collection<String> updatedColumns) {
for (ReferenceInfo referenceInfo : referencedReferenceInfos) {
for (String columnName : updatedColumns) {
if (referenceInfo.ident().columnIdent().fqn().equals(columnName)
|| referenceInfo.ident().columnIdent().isChildOf(ColumnIdent.fromPath(columnName))) {
return true;
}
}
}
return false;
}
/** extracts index definitions as well */
@SuppressWarnings("unchecked")
private void internalExtractColumnDefinitions(
ColumnIdent columnIdent, Map<String, Object> propertiesMap) {
if (propertiesMap == null) {
return;
}
for (Map.Entry<String, Object> columnEntry : propertiesMap.entrySet()) {
Map<String, Object> columnProperties = (Map) columnEntry.getValue();
DataType columnDataType = getColumnDataType(columnProperties);
ColumnIdent newIdent = childIdent(columnIdent, columnEntry.getKey());
columnProperties = furtherColumnProperties(columnProperties);
ReferenceInfo.IndexType columnIndexType = getColumnIndexType(columnProperties);
if (columnDataType == DataTypes.OBJECT
|| (columnDataType.id() == ArrayType.ID
&& ((ArrayType) columnDataType).innerType() == DataTypes.OBJECT)) {
ColumnPolicy columnPolicy = ColumnPolicy.of(columnProperties.get("dynamic"));
add(newIdent, columnDataType, columnPolicy, ReferenceInfo.IndexType.NO, false);
if (columnProperties.get("properties") != null) {
// walk nested
internalExtractColumnDefinitions(
newIdent, (Map<String, Object>) columnProperties.get("properties"));
}
} else if (columnDataType != DataTypes.NOT_SUPPORTED) {
List<String> copyToColumns = getNested(columnProperties, "copy_to");
// extract columns this column is copied to, needed for indices
if (copyToColumns != null) {
for (String copyToColumn : copyToColumns) {
ColumnIdent targetIdent = ColumnIdent.fromPath(copyToColumn);
IndexReferenceInfo.Builder builder = getOrCreateIndexBuilder(targetIdent);
builder.addColumn(
newInfo(newIdent, columnDataType, ColumnPolicy.DYNAMIC, columnIndexType));
}
}
// is it an index?
if (indicesMap.containsKey(newIdent.fqn())) {
IndexReferenceInfo.Builder builder = getOrCreateIndexBuilder(newIdent);
builder
.indexType(columnIndexType)
.ident(new ReferenceIdent(ident, newIdent))
.analyzer((String) columnProperties.get("analyzer"));
} else {
add(newIdent, columnDataType, columnIndexType);
}
}
}
}
/**
* Prepares an update request by converting it into an index request.
*
* <p>TODO: detect a NOOP and return an update response if true
*/
@SuppressWarnings("unchecked")
public IndexRequest prepareUpdate(
DocTableInfo tableInfo,
ShardUpsertRequest request,
ShardUpsertRequest.Item item,
ShardId shardId)
throws ElasticsearchException {
IndexService indexService = indicesService.indexServiceSafe(shardId.getIndex());
IndexShard indexShard = indexService.shardSafe(shardId.id());
final GetResult getResult =
indexShard
.getService()
.get(
request.type(),
item.id(),
new String[] {RoutingFieldMapper.NAME, ParentFieldMapper.NAME, TTLFieldMapper.NAME},
true,
item.version(),
VersionType.INTERNAL,
FetchSourceContext.FETCH_SOURCE,
false);
if (!getResult.isExists()) {
throw new DocumentMissingException(
new ShardId(request.index(), request.shardId()), request.type(), item.id());
}
if (getResult.internalSourceRef() == null) {
// no source, we can't do nothing, through a failure...
throw new DocumentSourceMissingException(
new ShardId(request.index(), request.shardId()), request.type(), item.id());
}
Tuple<XContentType, Map<String, Object>> sourceAndContent =
XContentHelper.convertToMap(getResult.internalSourceRef(), true);
final Map<String, Object> updatedSourceAsMap;
final XContentType updateSourceContentType = sourceAndContent.v1();
String routing =
getResult.getFields().containsKey(RoutingFieldMapper.NAME)
? getResult.field(RoutingFieldMapper.NAME).getValue().toString()
: null;
String parent =
getResult.getFields().containsKey(ParentFieldMapper.NAME)
? getResult.field(ParentFieldMapper.NAME).getValue().toString()
: null;
updatedSourceAsMap = sourceAndContent.v2();
SymbolToFieldExtractorContext ctx =
new SymbolToFieldExtractorContext(functions, item.insertValues());
Map<String, Object> pathsToUpdate = new LinkedHashMap<>();
Map<String, Object> updatedGeneratedColumns = new LinkedHashMap<>();
for (int i = 0; i < request.updateColumns().length; i++) {
/**
* NOTE: mapping isn't applied. So if an Insert was done using the ES Rest Endpoint the data
* might be returned in the wrong format (date as string instead of long)
*/
String columnPath = request.updateColumns()[i];
Object value =
SYMBOL_TO_FIELD_EXTRACTOR.convert(item.updateAssignments()[i], ctx).extract(getResult);
ReferenceInfo referenceInfo = tableInfo.getReferenceInfo(ColumnIdent.fromPath(columnPath));
if (referenceInfo instanceof GeneratedReferenceInfo) {
updatedGeneratedColumns.put(columnPath, value);
} else {
pathsToUpdate.put(columnPath, value);
}
}
processGeneratedColumns(
tableInfo,
pathsToUpdate,
updatedGeneratedColumns,
request.validateGeneratedColumns(),
getResult);
updateSourceByPaths(updatedSourceAsMap, pathsToUpdate);
final IndexRequest indexRequest =
Requests.indexRequest(request.index())
.type(request.type())
.id(item.id())
.routing(routing)
.parent(parent)
.source(updatedSourceAsMap, updateSourceContentType)
.version(getResult.getVersion());
indexRequest.operationThreaded(false);
return indexRequest;
}