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
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
|
// Copyright Yahoo. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
package com.yahoo.vespa.indexinglanguage;
import com.yahoo.document.DataType;
import com.yahoo.document.Document;
import com.yahoo.document.DocumentType;
import com.yahoo.document.DocumentUpdate;
import com.yahoo.document.Field;
import com.yahoo.document.FieldPath;
import com.yahoo.document.datatypes.Array;
import com.yahoo.document.datatypes.FieldValue;
import com.yahoo.document.datatypes.IntegerFieldValue;
import com.yahoo.document.datatypes.MapFieldValue;
import com.yahoo.document.datatypes.StringFieldValue;
import com.yahoo.document.datatypes.StructuredFieldValue;
import com.yahoo.document.datatypes.WeightedSet;
import com.yahoo.document.update.AddValueUpdate;
import com.yahoo.document.update.ArithmeticValueUpdate;
import com.yahoo.document.update.AssignValueUpdate;
import com.yahoo.document.update.ClearValueUpdate;
import com.yahoo.document.update.FieldUpdate;
import com.yahoo.document.update.MapValueUpdate;
import com.yahoo.document.update.RemoveValueUpdate;
import com.yahoo.document.update.TensorAddUpdate;
import com.yahoo.document.update.TensorModifyUpdate;
import com.yahoo.document.update.TensorRemoveUpdate;
import com.yahoo.document.update.ValueUpdate;
import com.yahoo.vespa.indexinglanguage.expressions.Expression;
import com.yahoo.vespa.indexinglanguage.expressions.FieldValueAdapter;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
/**
* @author Simon Thoresen Hult
*/
@SuppressWarnings("rawtypes")
public class FieldUpdateAdapter implements UpdateAdapter {
private final DocumentAdapter adapter;
private final Builder builder;
private final Expression optimizedExpression;
private FieldUpdateAdapter(Expression optimizedExpression, DocumentAdapter adapter, Builder builder) {
this.adapter = adapter;
this.builder = builder;
this.optimizedExpression = optimizedExpression;
}
@Override
public DocumentUpdate getOutput() {
Document doc = adapter.getUpdatableOutput();
DocumentUpdate upd = new DocumentUpdate(doc.getDataType(), doc.getId());
for (Iterator<Map.Entry<Field, FieldValue>> it = doc.iterator(); it.hasNext();) {
Map.Entry<Field, FieldValue> entry = it.next();
Field field = entry.getKey();
if (field.getName().equals("sddocname")) {
continue;
}
FieldUpdate fieldUpd = FieldUpdate.create(field);
fieldUpd.addValueUpdates(builder.build(entry.getValue()));
if (!fieldUpd.isEmpty()) {
upd.addFieldUpdate(fieldUpd);
}
}
return upd.isEmpty() ? null : upd;
}
@Override
public Expression getExpression(Expression expression) {
return optimizedExpression != null ? optimizedExpression : expression;
}
@Override
public DataType getInputType(Expression exp, String fieldName) {
return adapter.getInputType(exp, fieldName);
}
@Override
public FieldValue getInputValue(String fieldName) {
return adapter.getInputValue(fieldName);
}
@Override
public FieldValue getInputValue(FieldPath fieldPath) { return adapter.getInputValue(fieldPath); }
@Override
public void tryOutputType(Expression exp, String fieldName, DataType valueType) {
adapter.tryOutputType(exp, fieldName, valueType);
}
@Override
public FieldValueAdapter setOutputValue(Expression exp, String fieldName, FieldValue fieldValue) {
return adapter.setOutputValue(exp, fieldName, fieldValue);
}
@Override
public DocumentType getDocumentType() { return adapter.getDocumentType(); }
public static FieldUpdateAdapter fromPartialUpdate(DocumentAdapter documentAdapter, ValueUpdate valueUpdate) {
return new FieldUpdateAdapter(null, documentAdapter, new PartialBuilder(valueUpdate));
}
public static FieldUpdateAdapter fromPartialUpdate(Expression expression, DocumentAdapter documentAdapter, ValueUpdate valueUpdate) {
return new FieldUpdateAdapter(expression, documentAdapter, new PartialBuilder(valueUpdate));
}
public static FieldUpdateAdapter fromCompleteUpdate(DocumentAdapter documentAdapter) {
return new FieldUpdateAdapter(null, documentAdapter, new CompleteBuilder());
}
private interface Builder {
List<ValueUpdate> build(FieldValue val);
}
private static class PartialBuilder implements Builder {
final ValueUpdate update;
PartialBuilder(ValueUpdate update) {
this.update = update;
}
@Override
public List<ValueUpdate> build(FieldValue val) {
return createValueUpdates(val, update);
}
@SuppressWarnings({ "unchecked" })
List<ValueUpdate> createValueUpdates(FieldValue val, ValueUpdate upd) {
List<ValueUpdate> lst = new ArrayList<>();
if (upd instanceof ClearValueUpdate) {
lst.add(new ClearValueUpdate());
} else if (upd instanceof AssignValueUpdate) {
lst.add(new AssignValueUpdate(val));
} else if (upd instanceof AddValueUpdate) {
if (val instanceof Array) {
lst.addAll(createAddValueUpdateForArray((Array)val, ((AddValueUpdate)upd).getWeight()));
} else if (val instanceof WeightedSet) {
lst.addAll(createAddValueUpdateForWset((WeightedSet)val));
} else {
// do nothing
}
} else if (upd instanceof ArithmeticValueUpdate) {
lst.add(upd); // leave arithmetics alone
} else if (upd instanceof RemoveValueUpdate) {
if (val instanceof Array) {
lst.addAll(createRemoveValueUpdateForEachElement(((Array)val).fieldValueIterator()));
} else if (val instanceof WeightedSet) {
lst.addAll(createRemoveValueUpdateForEachElement(((WeightedSet)val).fieldValueIterator()));
} else {
// do nothing
}
} else if (upd instanceof MapValueUpdate) {
if (val instanceof Array) {
lst.addAll(createMapValueUpdatesForArray((Array)val, (MapValueUpdate)upd));
} else if (val instanceof MapFieldValue) {
throw new UnsupportedOperationException("Can not map into a " + val.getClass().getName() + ".");
} else if (val instanceof StructuredFieldValue) {
lst.addAll(createMapValueUpdatesForStruct((StructuredFieldValue)val, (MapValueUpdate)upd));
} else if (val instanceof WeightedSet) {
lst.addAll(createMapValueUpdatesForWset((WeightedSet)val, (MapValueUpdate)upd));
} else {
// do nothing
}
} else if (upd instanceof TensorModifyUpdate) {
lst.add(upd);
} else if (upd instanceof TensorAddUpdate) {
lst.add(upd);
} else if (upd instanceof TensorRemoveUpdate) {
lst.add(upd);
} else {
throw new UnsupportedOperationException(
"Value update type " + upd.getClass().getName() + " not supported.");
}
return lst;
}
@SuppressWarnings({ "unchecked" })
private List<ValueUpdate> createAddValueUpdateForArray(Array arr, int weight) {
List<ValueUpdate> ret = new ArrayList<>(arr.size());
for (Iterator<FieldValue> it = arr.fieldValueIterator(); it.hasNext(); ) {
ret.add(new AddValueUpdate(it.next(), weight));
}
return ret;
}
@SuppressWarnings({ "unchecked" })
private List<ValueUpdate> createAddValueUpdateForWset(WeightedSet wset) {
List<ValueUpdate> ret = new ArrayList<>(wset.size());
for (Iterator<FieldValue> it = wset.fieldValueIterator(); it.hasNext(); ) {
FieldValue key = it.next();
ret.add(new AddValueUpdate(key, wset.get(key)));
}
return ret;
}
@SuppressWarnings({ "unchecked" })
private List<ValueUpdate> createRemoveValueUpdateForEachElement(Iterator<FieldValue> it) {
List<ValueUpdate> ret = new ArrayList<>();
while (it.hasNext()) {
ret.add(new RemoveValueUpdate(it.next()));
}
return ret;
}
@SuppressWarnings({ "unchecked" })
private List<ValueUpdate> createMapValueUpdatesForArray(Array arr, MapValueUpdate upd) {
List<ValueUpdate> ret = new ArrayList<>();
for (Iterator<FieldValue> it = arr.fieldValueIterator(); it.hasNext();) {
FieldValue childVal = it.next();
for (ValueUpdate childUpd : createValueUpdates(childVal, upd.getUpdate())) {
// The array update is always directed towards a particular array index, which is
// kept as the _value_ in the original update.
ret.add(new MapValueUpdate(upd.getValue(), childUpd));
}
}
return ret;
}
@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;
}
@SuppressWarnings({ "unchecked" })
private List<ValueUpdate> createMapValueUpdatesForWset(WeightedSet wset, MapValueUpdate upd) {
List<ValueUpdate> ret = new ArrayList<>();
for (Iterator<FieldValue> it = wset.fieldValueIterator(); it.hasNext();) {
FieldValue childVal = it.next();
for (ValueUpdate childUpd : createValueUpdates(new IntegerFieldValue(wset.get(childVal)),
upd.getUpdate()))
{
ret.add(new MapValueUpdate(childVal, childUpd));
}
}
return ret;
}
}
private static class CompleteBuilder extends PartialBuilder {
static final ValueUpdate nullAssign = new AssignValueUpdate(null);
CompleteBuilder() {
super(null);
}
@Override
List<ValueUpdate> createValueUpdates(FieldValue val, ValueUpdate upd) {
return super.createValueUpdates(val, nullAssign);
}
}
}
|
