1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
|
// Copyright Yahoo. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
package com.yahoo.schema.parser;
import com.yahoo.schema.OnnxModel;
import com.yahoo.schema.RankProfile;
import com.yahoo.schema.document.Stemming;
import com.yahoo.searchlib.rankingexpression.Reference;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Optional;
/**
* This class holds the extracted information after parsing
* one schema (.sd) file, using simple data structures
* as far as possible.
*
* Do not put complicated logic here!
*
* @author arnej27959
*/
public class ParsedSchema extends ParsedBlock {
public static class ImportedField {
public final String asFieldName;
public final String refFieldName;
public final String foreignFieldName;
public ImportedField(String asField, String refField, String foreignField) {
this.asFieldName = asField;
this.refFieldName = refField;
this.foreignFieldName = foreignField;
}
}
private boolean documentWithoutSchema = false;
private Boolean rawAsBase64 = null;
private ParsedDocument myDocument = null;
private Stemming defaultStemming = null;
private final List<ImportedField> importedFields = new ArrayList<>();
private final List<OnnxModel> onnxModels = new ArrayList<>();
private final Map<Reference, RankProfile.Constant> constants = new LinkedHashMap<>();
private final List<String> inherited = new ArrayList<>();
private final List<String> inheritedByDocument = new ArrayList<>();
private final Map<String, ParsedSchema> resolvedInherits = new LinkedHashMap<>();
private final Map<String, ParsedSchema> allResolvedInherits = new LinkedHashMap<>();
private final Map<String, ParsedAnnotation> extraAnnotations = new LinkedHashMap<>();
private final Map<String, ParsedDocumentSummary> docSums = new LinkedHashMap<>();
private final Map<String, ParsedField> extraFields = new LinkedHashMap<>();
private final Map<String, ParsedFieldSet> fieldSets = new LinkedHashMap<>();
private final Map<String, ParsedIndex> extraIndexes = new LinkedHashMap<>();
private final Map<String, ParsedRankProfile> rankProfiles = new LinkedHashMap<>();
private final Map<String, ParsedStruct> extraStructs = new LinkedHashMap<>();
public ParsedSchema(String name) {
super(name, "schema");
}
boolean getDocumentWithoutSchema() { return documentWithoutSchema; }
Optional<Boolean> getRawAsBase64() { return Optional.ofNullable(rawAsBase64); }
boolean hasDocument() { return myDocument != null; }
ParsedDocument getDocument() { return myDocument; }
boolean hasStemming() { return defaultStemming != null; }
Stemming getStemming() { return defaultStemming; }
List<ImportedField> getImportedFields() { return List.copyOf(importedFields); }
List<OnnxModel> getOnnxModels() { return List.copyOf(onnxModels); }
List<ParsedAnnotation> getAnnotations() { return List.copyOf(extraAnnotations.values()); }
List<ParsedDocumentSummary> getDocumentSummaries() { return List.copyOf(docSums.values()); }
List<ParsedField> getFields() { return List.copyOf(extraFields.values()); }
List<ParsedFieldSet> getFieldSets() { return List.copyOf(fieldSets.values()); }
List<ParsedIndex> getIndexes() { return List.copyOf(extraIndexes.values()); }
List<ParsedStruct> getStructs() { return List.copyOf(extraStructs.values()); }
List<String> getInherited() { return List.copyOf(inherited); }
List<String> getInheritedByDocument() { return List.copyOf(inheritedByDocument); }
List<ParsedRankProfile> getRankProfiles() { return List.copyOf(rankProfiles.values()); }
List<ParsedSchema> getResolvedInherits() { return List.copyOf(resolvedInherits.values()); }
List<ParsedSchema> getAllResolvedInherits() { return List.copyOf(allResolvedInherits.values()); }
List<RankProfile.Constant> getConstants() { return List.copyOf(constants.values()); }
void addAnnotation(ParsedAnnotation annotation) {
String annName = annotation.name();
verifyThat(! extraAnnotations.containsKey(annName), "already has annotation", annName);
extraAnnotations.put(annName, annotation);
}
void addDocument(ParsedDocument document) {
verifyThat(myDocument == null,
"already has", myDocument, "so cannot add", document);
// TODO - disallow?
// verifyThat(name().equals(document.name()),
// "schema " + name() + " can only contain document named " + name() + ", was: "+ document.name());
this.myDocument = document;
}
void setDocumentWithoutSchema() { this.documentWithoutSchema = true; }
void addDocumentSummary(ParsedDocumentSummary docsum) {
String dsName = docsum.name();
verifyThat(! docSums.containsKey(dsName), "already has document-summary", dsName);
docSums.put(dsName, docsum);
}
void addField(ParsedField field) {
String fieldName = field.name();
verifyThat(! extraFields.containsKey(fieldName), "already has field", fieldName);
extraFields.put(fieldName, field);
}
void addFieldSet(ParsedFieldSet fieldSet) {
String fsName = fieldSet.name();
verifyThat(! fieldSets.containsKey(fsName), "already has fieldset", fsName);
fieldSets.put(fsName, fieldSet);
}
void addImportedField(String asFieldName, String refFieldName, String foregnFieldName) {
importedFields.add(new ImportedField(asFieldName, refFieldName, foregnFieldName));
}
void addIndex(ParsedIndex index) {
String idxName = index.name();
verifyThat(! extraIndexes.containsKey(idxName), "already has index", idxName);
extraIndexes.put(idxName, index);
}
void add(OnnxModel model) {
onnxModels.add(model);
}
void addRankProfile(ParsedRankProfile profile) {
String rpName = profile.name();
verifyThat(! rankProfiles.containsKey(rpName), "already has rank-profile", rpName);
rankProfiles.put(rpName, profile);
}
void add(RankProfile.Constant constant) {
constants.put(constant.name(), constant);
}
void addStruct(ParsedStruct struct) {
String sName = struct.name();
verifyThat(! extraStructs.containsKey(sName), "already has struct", sName);
extraStructs.put(sName, struct);
}
void enableRawAsBase64(boolean value) {
this.rawAsBase64 = value;
}
void inherit(String other) { inherited.add(other); }
void inheritByDocument(String other) { inheritedByDocument.add(other); }
void setStemming(Stemming value) {
verifyThat((defaultStemming == null) || (defaultStemming == value),
"already has stemming", defaultStemming, "cannot also set", value);
defaultStemming = value;
}
void resolveInherit(String name, ParsedSchema parsed) {
verifyThat(inherited.contains(name), "resolveInherit for non-inherited name", name);
verifyThat(name.equals(parsed.name()), "resolveInherit name mismatch for", name);
verifyThat(! resolvedInherits.containsKey(name), "double resolveInherit for", name);
resolvedInherits.put(name, parsed);
var old = allResolvedInherits.put("schema " + name, parsed);
verifyThat(old == null || old == parsed, "conflicting resolveInherit for", name);
}
void resolveInheritByDocument(String name, ParsedSchema parsed) {
verifyThat(inheritedByDocument.contains(name),
"resolveInheritByDocument for non-inherited name", name);
var old = allResolvedInherits.put("document " + name, parsed);
verifyThat(old == null || old == parsed, "conflicting resolveInheritByDocument for", name);
}
}
|
