From 8dcd269877eeaad8ca58274e5d992051e06fb4eb Mon Sep 17 00:00:00 2001 From: Arne H Juul Date: Thu, 31 Mar 2022 13:03:41 +0000 Subject: copy code from DocumentManager.java * the difference from DocumentManager is that here we provide the "internalid" for all types also. * currently not active --- .../vespa/configmodel/producers/DocumentTypes.java | 290 +++++++++++++++++++++ 1 file changed, 290 insertions(+) (limited to 'config-model/src') diff --git a/config-model/src/main/java/com/yahoo/vespa/configmodel/producers/DocumentTypes.java b/config-model/src/main/java/com/yahoo/vespa/configmodel/producers/DocumentTypes.java index e1a28c8114f..630e9f0c097 100644 --- a/config-model/src/main/java/com/yahoo/vespa/configmodel/producers/DocumentTypes.java +++ b/config-model/src/main/java/com/yahoo/vespa/configmodel/producers/DocumentTypes.java @@ -27,6 +27,11 @@ public class DocumentTypes { } public DocumenttypesConfig.Builder produce(DocumentModel model, DocumenttypesConfig.Builder builder) { + /* later: + if (some flag) { + return produceDocTypes(model, builder); + } + */ builder.usev8geopositions(this.useV8GeoPositions); Map produced = new HashMap<>(); for (NewDocumentType documentType : model.getDocumentManager().getTypes()) { @@ -236,4 +241,289 @@ public class DocumentTypes { documentBuilder.referencetype(refBuilder); } + // Alternate (new) way to build config: + + private DocumenttypesConfig.Builder produceDocTypes(DocumentModel model, DocumenttypesConfig.Builder builder) { + builder.usev8geopositions(this.useV8GeoPositions); + Map produced = new HashMap<>(); + var indexMap = new IdxMap(); + for (NewDocumentType documentType : model.getDocumentManager().getTypes()) { + docTypeInheritOrder(documentType, builder, produced, indexMap); + } + indexMap.verifyAllDone(); + return builder; + } + + private void docTypeInheritOrder(NewDocumentType documentType, + DocumenttypesConfig.Builder builder, + Map produced, + IdxMap indexMap) + { + if (! produced.containsKey(documentType.getFullName())) { + for (NewDocumentType inherited : documentType.getInherited()) { + docTypeInheritOrder(inherited, builder, produced, indexMap); + } + docTypeBuild(documentType, builder, indexMap); + produced.put(documentType.getFullName(), documentType); + } + } + + static private class IdxMap { + private Map doneMap = new HashMap<>(); + private Map map = new IdentityHashMap<>(); + void add(Object someType) { + assert(someType != null); + // the adding of "10000" here is mostly to make it more + // unique to grep for when debugging + int nextIdx = 10000 + map.size(); + map.computeIfAbsent(someType, k -> nextIdx); + } + int idxOf(Object someType) { + if (someType instanceof DocumentType) { + var dt = (DocumentType) someType; + if (dt.getId() == 8) { + return idxOf(VespaDocumentType.INSTANCE); + } + } + add(someType); + return map.get(someType); + } + boolean isDone(Object someType) { + return doneMap.computeIfAbsent(idxOf(someType), k -> false); + } + void setDone(Object someType) { + assert(! isDone(someType)); + doneMap.put(idxOf(someType), true); + } + void verifyAllDone() { + for (var entry : map.entrySet()) { + Object needed = entry.getKey(); + if (! isDone(needed)) { + throw new IllegalArgumentException("Could not generate config for all needed types, missing: " + + needed + " of class " + needed.getClass()); + } + } + } + } + + private void docTypeBuild(NewDocumentType documentType, DocumenttypesConfig.Builder builder, IdxMap indexMap) { + DocumenttypesConfig.Doctype.Builder db = new DocumenttypesConfig.Doctype.Builder(); + db. + idx(indexMap.idxOf(documentType)). + name(documentType.getName()). + internalid(documentType.getId()). + contentstruct(indexMap.idxOf(documentType.getContentStruct())); + docTypeBuildFieldSets(documentType.getFieldSets(), db); + docTypeBuildImportedFields(documentType.getImportedFieldNames(), db); + for (NewDocumentType inherited : documentType.getInherited()) { + db.inherits(b -> b.idx(indexMap.idxOf(inherited))); + } + docTypeBuildAnyType(documentType.getContentStruct(), db, indexMap); + + for (DataType dt : sortedList(documentType.getAllTypes().getTypes(), + (a,b) -> a.getName().compareTo(b.getName()))) { + docTypeBuildAnyType(dt, db, indexMap); + } + for (AnnotationType ann : sortedList(documentType.getAnnotations(), + (a,b) -> a.getName().compareTo(b.getName()))) { + docTypeBuildAnnotationType(ann, db, indexMap); + } + builder.doctype(db); + indexMap.setDone(documentType); + } + + private void docTypeBuildFieldSets(Set
fieldSets, DocumenttypesConfig.Doctype.Builder db) { + for (FieldSet fs : fieldSets) { + docTypeBuildOneFieldSet(fs, db); + } + } + + private void docTypeBuildOneFieldSet(FieldSet fs, DocumenttypesConfig.Doctype.Builder db) { + db.fieldsets(fs.getName(), new DocumenttypesConfig.Doctype.Fieldsets.Builder().fields(fs.getFieldNames())); + } + + private void docTypeBuildAnnotationType(AnnotationType annotation, DocumenttypesConfig.Doctype.Builder builder, IdxMap indexMap) { + if (indexMap.isDone(annotation)) { + return; + } + indexMap.setDone(annotation); + var annBuilder = new DocumenttypesConfig.Doctype.Annotationtype.Builder(); + annBuilder + .idx(indexMap.idxOf(annotation)) + .name(annotation.getName()) + .internalid(annotation.getId()); + DataType nested = annotation.getDataType(); + if (nested != null) { + annBuilder.datatype(indexMap.idxOf(nested)); + docTypeBuildAnyType(nested, builder, indexMap); + } + for (AnnotationType inherited : annotation.getInheritedTypes()) { + annBuilder.inherits(inhBuilder -> inhBuilder.idx(indexMap.idxOf(inherited))); + + } + builder.annotationtype(annBuilder); + } + + @SuppressWarnings("deprecation") + private void docTypeBuildAnyType(DataType type, DocumenttypesConfig.Doctype.Builder documentBuilder, IdxMap indexMap) { + if (indexMap.isDone(type)) { + return; + } + if (type instanceof NewDocumentType) { + // should be in the top-level list and handled there + return; + } + if ((type instanceof DocumentType) && (type.getId() == 8)) { + // special handling + return; + } + indexMap.setDone(type); + if (type instanceof TemporaryStructuredDataType) { + throw new IllegalArgumentException("Can not create config for temporary data type: " + type.getName()); + } else if (type instanceof TemporaryUnknownType) { + throw new IllegalArgumentException("Can not create config for temporary data type: " + type.getName()); + } else if (type instanceof OwnedTemporaryType) { + throw new IllegalArgumentException("Can not create config for temporary data type: " + type.getName()); + } else if (type instanceof StructDataType) { + docTypeBuildOneType((StructDataType) type, documentBuilder, indexMap); + } else if (type instanceof ArrayDataType) { + docTypeBuildOneType((ArrayDataType) type, documentBuilder, indexMap); + } else if (type instanceof WeightedSetDataType) { + docTypeBuildOneType((WeightedSetDataType) type, documentBuilder, indexMap); + } else if (type instanceof MapDataType) { + docTypeBuildOneType((MapDataType) type, documentBuilder, indexMap); + } else if (type instanceof AnnotationReferenceDataType) { + docTypeBuildOneType((AnnotationReferenceDataType) type, documentBuilder, indexMap); + } else if (type instanceof TensorDataType) { + docTypeBuildOneType((TensorDataType) type, documentBuilder, indexMap); + } else if (type instanceof NewDocumentReferenceDataType) { + var refType = (NewDocumentReferenceDataType) type; + if (refType.isTemporary()) { + throw new IllegalArgumentException("Still temporary: " + refType); + } + docTypeBuildOneType(refType, documentBuilder, indexMap); + } else if (type instanceof PrimitiveDataType) { + docTypeBuildOneType((PrimitiveDataType) type, documentBuilder, indexMap); + } else if (type instanceof DocumentType) { + throw new IllegalArgumentException("Can not create config for unadorned document type: " + type.getName() + " id "+type.getId()); + } else { + throw new IllegalArgumentException("Can not create config for data type " + type + " of class " + type.getClass()); + } + } + + private void docTypeBuildImportedFields(Collection fieldNames, DocumenttypesConfig.Doctype.Builder builder) { + for (String fieldName : fieldNames) { + builder.importedfield(ib -> ib.name(fieldName)); + } + } + + private void docTypeBuildOneType(StructDataType type, + DocumenttypesConfig.Doctype.Builder builder, + IdxMap indexMap) + { + var structBuilder = new DocumenttypesConfig.Doctype.Structtype.Builder(); + structBuilder + .idx(indexMap.idxOf(type)) + .name(type.getName()) + .internalid(type.getId()); + for (DataType inherited : type.getInheritedTypes()) { + structBuilder.inherits(inheritBuilder -> inheritBuilder + .type(indexMap.idxOf(inherited))); + docTypeBuildAnyType(inherited, builder, indexMap); + } + for (com.yahoo.document.Field field : type.getFieldsThisTypeOnly()) { + DataType fieldType = field.getDataType(); + structBuilder.field(fieldBuilder -> fieldBuilder + .name(field.getName()) + .internalid(field.getId()) + .type(indexMap.idxOf(fieldType))); + docTypeBuildAnyType(fieldType, builder, indexMap); + } + builder.structtype(structBuilder); + } + + private void docTypeBuildOneType(PrimitiveDataType type, + DocumenttypesConfig.Doctype.Builder builder, + IdxMap indexMap) + { + builder.primitivetype(primBuilder -> primBuilder + .idx(indexMap.idxOf(type)) + .name(type.getName())); + } + + private void docTypeBuildOneType(TensorDataType type, + DocumenttypesConfig.Doctype.Builder builder, + IdxMap indexMap) + { + var tt = type.getTensorType(); + String detailed = (tt != null) ? tt.toString() : "tensor"; + builder.tensortype(tensorBuilder -> tensorBuilder + .idx(indexMap.idxOf(type)) + .detailedtype(detailed)); + + } + + private void docTypeBuildOneType(ArrayDataType type, + DocumenttypesConfig.Doctype.Builder builder, + IdxMap indexMap) + { + DataType nested = type.getNestedType(); + System.err.println("array of "+nested+" -> "+type.getName()+" id "+type.getId()); + builder.arraytype(arrayBuilder -> arrayBuilder + .idx(indexMap.idxOf(type)) + .elementtype(indexMap.idxOf(nested)) + .internalid(type.getId())); + docTypeBuildAnyType(nested, builder, indexMap); + } + + private void docTypeBuildOneType(WeightedSetDataType type, + DocumenttypesConfig.Doctype.Builder builder, + IdxMap indexMap) + { + DataType nested = type.getNestedType(); + builder.wsettype(wsetBuilder -> wsetBuilder + .idx(indexMap.idxOf(type)) + .elementtype(indexMap.idxOf(nested)) + .createifnonexistent(type.createIfNonExistent()) + .removeifzero(type.removeIfZero()) + .internalid(type.getId())); + docTypeBuildAnyType(nested, builder, indexMap); + } + + private void docTypeBuildOneType(MapDataType type, + DocumenttypesConfig.Doctype.Builder builder, + IdxMap indexMap) + { + DataType keytype = type.getKeyType(); + DataType valtype = type.getValueType(); + builder.maptype(mapBuilder -> mapBuilder + .idx(indexMap.idxOf(type)) + .keytype(indexMap.idxOf(keytype)) + .valuetype(indexMap.idxOf(valtype)) + .internalid(type.getId())); + docTypeBuildAnyType(keytype, builder, indexMap); + docTypeBuildAnyType(valtype, builder, indexMap); + } + + private void docTypeBuildOneType(AnnotationReferenceDataType type, + DocumenttypesConfig.Doctype.Builder builder, + IdxMap indexMap) + { + builder.annotationref(arefBuilder -> arefBuilder + .idx(indexMap.idxOf(type)) + .annotationtype(indexMap.idxOf(type.getAnnotationType())) + .internalid(type.getId())); + } + + private void docTypeBuildOneType(NewDocumentReferenceDataType type, + DocumenttypesConfig.Doctype.Builder builder, + IdxMap indexMap) + { + builder.documentref(docrefBuilder -> docrefBuilder + .idx(indexMap.idxOf(type)) + .targettype(indexMap.idxOf(type.getTargetType())) + .internalid(type.getId())); + + } + } -- cgit v1.2.3