MyConverter(Search search, Field field, Set<String> summaryFields, boolean validate) { this.search = search; this.field = field; this.summaryFields = summaryFields.isEmpty() ? Collections.singleton(field.getName()) : summaryFields; this.validate = validate; }
public SearchField(Field field, boolean indexed, boolean attribute, List<Feature> features) { super(field.getName(), field); this.attribute = attribute; this.indexed = indexed; if (features != null) { featureList.addAll(features); } validate(); }
private Map<String, Field> fieldsInherited() { Map<String, Field> map = new LinkedHashMap<>(); for (SDDocumentType parent : inheritedTypes.values()) { for (Field field : parent.fieldSet()) { map.put(field.getName(), field); } } return map; }
public Context(Field field, AttributeFields attributes) { this.field = field; this.structFieldAttributes = attributes.structFieldAttributes(field.getName()); }
public void addField(Field field) { verifyInheritance(field); for (Iterator<Field> i = docType.fieldIteratorThisTypeOnly(); i.hasNext(); ) { if (field.getName().equalsIgnoreCase((i.next()).getName())) { throw new IllegalArgumentException("Duplicate (case insensitively) " + field + " in " + this); } } docType.addField(field); }
public Set<Field> fieldSet() { Map<String, Field> map = fieldsInherited(); Iterator<Field> it = docType.fieldIteratorThisTypeOnly(); while (it.hasNext()) { Field field = it.next(); map.put(field.getName(), field); } return new LinkedHashSet<>(map.values()); }
private void deriveIndexFields(Field field, Search search) { IndexField toAdd = new IndexField(field.getName(), Index.convertType(field.getDataType()), field.getDataType()); com.yahoo.searchdefinition.Index definedIndex = search.getIndex(field.getName()); if (definedIndex != null) { toAdd.setIndexSettings(definedIndex); } fields.add(toAdd); addFieldToCollection(field.getName(), field.getName()); // implicit }
private static String createErrorMessage(DocumentId docId, Field field, Throwable cause) { return String.format("Error in document '%s' - could not parse field '%s' of type '%s': %s", docId, field.getName(), field.getDataType().getName(), cause.getMessage()); }
@SuppressWarnings({ "unchecked" }) private List<ValueUpdate> createMapValueUpdatesForStruct(StructuredFieldValue struct, MapValueUpdate upd) { List<ValueUpdate> ret = new ArrayList<>(); for (Iterator<Map.Entry<Field, FieldValue>> it = struct.iterator(); it.hasNext();) { Map.Entry<Field, FieldValue> entry = it.next(); for (ValueUpdate childUpd : createValueUpdates(entry.getValue(), upd.getUpdate())) { ret.add(new MapValueUpdate(new StringFieldValue(entry.getKey().getName()), childUpd)); } } return ret; }
private static void expectFieldIsOfTypeTensor(Field field) { if (!(field.getDataType() instanceof TensorDataType)) { throw new IllegalArgumentException("A modify update can only be applied to tensor fields. " + "Field '" + field.getName() + "' is of type '" + field.getDataType().getName() + "'"); } }
private static void expectTensorTypeHasNoneIndexedUnboundDimensions(Field field) { TensorType tensorType = ((TensorDataType)field.getDataType()).getTensorType(); if (tensorType.dimensions().stream() .anyMatch(dim -> dim.type().equals(TensorType.Dimension.Type.indexedUnbound))) { throw new IllegalArgumentException("A modify update cannot be applied to tensor types with indexed unbound dimensions. " + "Field '" + field.getName() + "' has unsupported tensor type '" + tensorType + "'"); } }
@Override public void write(FieldBase field, StructuredFieldValue value) { buffer.beginTag(field.getName()); Iterator<Map.Entry<Field, FieldValue>> i = value.iterator(); while (i.hasNext()) { Map.Entry<Field, FieldValue> v = i.next(); buffer.beginTag(v.getKey().getName()); v.getValue().printXml(buffer); buffer.endTag(); } buffer.endTag(); }
@SuppressWarnings("deprecation") private static void specialHandleAnnotationReference(NewDocumentType docType, Field field) { DataType fieldType = specialHandleAnnotationReferenceRecurse(docType, field.getName(), field.getDataType()); if (fieldType == null) { return; } field.setDataType(fieldType); // XXX deprecated }
private void disallowIndexingOfMaps(AbstractSearchCluster cluster, SearchDefinition def, Field field) { DataType fieldType = field.getDataType(); if ((fieldType instanceof MapDataType) && (((SDField) field).doesIndexing())) { throw new IllegalArgumentException("Field type '" + fieldType.getName() + "' cannot be indexed for search " + "clusters (field '" + field.getName() + "' in definition '" + def.getName() + "' for cluster '" + cluster.getClusterName() + "')."); } } }
private static FieldChange createFieldChange(Field currentField, NewDocumentType nextDocType) { Field nextField = nextDocType.getField(currentField.getName()); if (nextField != null && areStructFields(currentField, nextField)) { return new StructFieldChange(currentField, nextField); } return new SimpleFieldChange(currentField, nextField); }
public static TensorModifyUpdate createModifyUpdate(TokenBuffer buffer, Field field) { expectFieldIsOfTypeTensor(field); expectTensorTypeHasNoneIndexedUnboundDimensions(field); expectTensorTypeIsNotMixed(field); expectObjectStart(buffer.currentToken()); ModifyUpdateResult result = createModifyUpdateResult(buffer, field); expectOperationSpecified(result.operation, field.getName()); expectTensorSpecified(result.tensor, field.getName()); return new TensorModifyUpdate(result.operation, result.tensor); }
private void addDocumentFieldSet() { for (Field docField : search.getDocument().fieldSet()) { if (docField instanceof SDField && ((SDField) docField).isExtraField()) { continue; // skip } search.fieldSets().addBuiltInFieldSetItem(DOC_FIELDSET_NAME, docField.getName()); } }
private static SDDocumentType createSDDocumentType(StructDataType structType) { SDDocumentType docType = new SDDocumentType(structType.getName()); for (Field field : structType.getFields()) { docType.addField(new SDField(docType, field.getName(), field.getDataType())); } docType.setStruct(structType); return docType; }
private static ImportedFieldsConfig.Attribute.Builder createAttributeBuilder(ImportedField field) { ImportedFieldsConfig.Attribute.Builder result = new ImportedFieldsConfig.Attribute.Builder(); result.name(field.fieldName()); result.referencefield(field.reference().referenceField().getName()); result.targetfield(field.targetField().getName()); return result; }
private void resolveImportedPositionField(TemporaryImportedField importedField, DocumentReference reference, ImmutableSDField targetField, boolean validate) { TemporaryImportedField importedZCurveField = new TemporaryImportedField(PositionDataType.getZCurveFieldName(importedField.fieldName()), reference.referenceField().getName(), PositionDataType.getZCurveFieldName(targetField.getName())); ImmutableSDField targetZCurveField = getTargetField(importedZCurveField, reference); resolveImportedNormalField(importedZCurveField, reference, targetZCurveField, validate); ImportedComplexField importedStructField = new ImportedComplexField(importedField.fieldName(), reference, targetField); registerImportedField(importedField, null, importedStructField); }