예제 #1
0
 /**
  * Returns all the fields that match the given pattern. If the pattern is prefixed with a type
  * then the fields will be returned with a type prefix.
  */
 public Collection<String> simpleMatchToIndexNames(String pattern) {
   if (Regex.isSimpleMatchPattern(pattern) == false) {
     // no wildcards
     return Collections.singletonList(pattern);
   }
   return fieldTypes.simpleMatchToFullName(pattern);
 }
예제 #2
0
 private boolean assertMappersShareSameFieldType() {
   for (DocumentMapper mapper : docMappers(false)) {
     List<FieldMapper> fieldMappers = new ArrayList<>();
     Collections.addAll(fieldMappers, mapper.mapping().metadataMappers);
     MapperUtils.collect(mapper.root(), new ArrayList<ObjectMapper>(), fieldMappers);
     for (FieldMapper fieldMapper : fieldMappers) {
       assert fieldMapper.fieldType() == fieldTypes.get(fieldMapper.name()) : fieldMapper.name();
     }
   }
   return true;
 }
예제 #3
0
  private void checkFieldUniqueness(
      String type, Collection<ObjectMapper> objectMappers, Collection<FieldMapper> fieldMappers) {
    assert Thread.holdsLock(this);

    // first check within mapping
    final Set<String> objectFullNames = new HashSet<>();
    for (ObjectMapper objectMapper : objectMappers) {
      final String fullPath = objectMapper.fullPath();
      if (objectFullNames.add(fullPath) == false) {
        throw new IllegalArgumentException(
            "Object mapper [" + fullPath + "] is defined twice in mapping for type [" + type + "]");
      }
    }

    final Set<String> fieldNames = new HashSet<>();
    for (FieldMapper fieldMapper : fieldMappers) {
      final String name = fieldMapper.name();
      if (objectFullNames.contains(name)) {
        throw new IllegalArgumentException(
            "Field [" + name + "] is defined both as an object and a field in [" + type + "]");
      } else if (fieldNames.add(name) == false) {
        throw new IllegalArgumentException(
            "Field [" + name + "] is defined twice in [" + type + "]");
      }
    }

    // then check other types
    for (String fieldName : fieldNames) {
      if (fullPathObjectMappers.containsKey(fieldName)) {
        throw new IllegalArgumentException(
            "["
                + fieldName
                + "] is defined as a field in mapping ["
                + type
                + "] but this name is already used for an object in other types");
      }
    }

    for (String objectPath : objectFullNames) {
      if (fieldTypes.get(objectPath) != null) {
        throw new IllegalArgumentException(
            "["
                + objectPath
                + "] is defined as an object in mapping ["
                + type
                + "] but this name is already used for a field in other types");
      }
    }
  }
예제 #4
0
 protected void checkNewMappersCompatibility(
     Collection<ObjectMapper> newObjectMappers,
     Collection<FieldMapper> newFieldMappers,
     boolean updateAllTypes) {
   assert mappingLock.isWriteLockedByCurrentThread();
   for (ObjectMapper newObjectMapper : newObjectMappers) {
     ObjectMapper existingObjectMapper = fullPathObjectMappers.get(newObjectMapper.fullPath());
     if (existingObjectMapper != null) {
       MergeResult result = new MergeResult(true, updateAllTypes);
       existingObjectMapper.merge(newObjectMapper, result);
       if (result.hasConflicts()) {
         throw new IllegalArgumentException(
             "Mapper for ["
                 + newObjectMapper.fullPath()
                 + "] conflicts with existing mapping in other types"
                 + Arrays.toString(result.buildConflicts()));
       }
     }
   }
   fieldTypes.checkCompatibility(newFieldMappers, updateAllTypes);
 }
예제 #5
0
 /**
  * Returns the {@link MappedFieldType} for the give fullName.
  *
  * <p>If multiple types have fields with the same full name, the first is returned.
  */
 public MappedFieldType fullName(String fullName) {
   return fieldTypes.get(fullName);
 }
예제 #6
0
 /**
  * Returns an {@link MappedFieldType} which has the given index name.
  *
  * <p>If multiple types have fields with the same index name, the first is returned.
  */
 public MappedFieldType indexName(String indexName) {
   return fieldTypes.getByIndexName(indexName);
 }