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
|
// Copyright 2018 Yahoo Holdings. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
package com.yahoo.searchdefinition.processing;
import com.yahoo.config.application.api.DeployLogger;
import com.yahoo.search.query.profile.QueryProfileRegistry;
import com.yahoo.searchdefinition.MapEvaluationTypeContext;
import com.yahoo.searchdefinition.RankProfile;
import com.yahoo.searchdefinition.RankProfileRegistry;
import com.yahoo.searchdefinition.Search;
import com.yahoo.searchlib.rankingexpression.ExpressionFunction;
import com.yahoo.searchlib.rankingexpression.RankingExpression;
import com.yahoo.searchlib.rankingexpression.Reference;
import com.yahoo.searchlib.rankingexpression.rule.ExpressionNode;
import com.yahoo.tensor.TensorType;
import com.yahoo.tensor.evaluation.TypeContext;
import com.yahoo.vespa.model.container.search.QueryProfiles;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import java.util.logging.Level;
/**
* Resolves and assigns types to all functions in a ranking expression, and
* validates the types of all ranking expressions under a search instance:
* Some operators constrain the types of inputs, and first-and second-phase expressions
* must return scalar values.
*
* In addition, the existence of all referred attribute, query and constant
* features is ensured.
*
* @author bratseth
*/
public class RankingExpressionTypeResolver extends Processor {
private final QueryProfileRegistry queryProfiles;
public RankingExpressionTypeResolver(Search search,
DeployLogger deployLogger,
RankProfileRegistry rankProfileRegistry,
QueryProfiles queryProfiles) {
super(search, deployLogger, rankProfileRegistry, queryProfiles);
this.queryProfiles = queryProfiles.getRegistry();
}
@Override
public void process(boolean validate, boolean documentsOnly) {
if (documentsOnly) return;
Set<Reference> warnedAbout = new HashSet<>();
for (RankProfile profile : rankProfileRegistry.rankProfilesOf(search)) {
try {
resolveTypesIn(profile, validate, warnedAbout);
}
catch (IllegalArgumentException e) {
throw new IllegalArgumentException("In " + (search != null ? search + ", " : "") + profile, e);
}
}
}
/**
* Resolves the types of all functions in the given profile
*
* @throws IllegalArgumentException if validate is true and the given rank profile does not produce valid types
*/
private void resolveTypesIn(RankProfile profile, boolean validate, Set<Reference> warnedAbout) {
MapEvaluationTypeContext context = profile.typeContext(queryProfiles);
for (Map.Entry<String, RankProfile.RankingExpressionFunction> function : profile.getFunctions().entrySet()) {
ExpressionFunction expressionFunction = function.getValue().function();
if (hasUntypedArguments(expressionFunction)) continue;
// Add any missing inputs for type resolution
for (String argument : expressionFunction.arguments()) {
Reference ref = Reference.fromIdentifier(argument);
if (context.getType(ref).equals(TensorType.empty)) {
context.setType(ref, expressionFunction.argumentTypes().get(argument));
}
}
context.forgetResolvedTypes();
TensorType type = resolveType(expressionFunction.getBody(), "function '" + function.getKey() + "'", context);
function.getValue().setReturnType(type);
}
if (validate) {
profile.getSummaryFeatures().forEach(f -> resolveType(f, "summary feature " + f, context));
ensureValidDouble(profile.getFirstPhaseRanking(), "first-phase expression", context);
ensureValidDouble(profile.getSecondPhaseRanking(), "second-phase expression", context);
if ( context.tensorsAreUsed() &&
! context.queryFeaturesNotDeclared().isEmpty() &&
! warnedAbout.containsAll(context.queryFeaturesNotDeclared())) {
deployLogger.log(Level.WARNING, "The following query features used in '" + profile.getName() +
"' are not declared in query profile " +
"types and will be interpreted as scalars, not tensors: " +
context.queryFeaturesNotDeclared());
warnedAbout.addAll(context.queryFeaturesNotDeclared());
}
}
}
private boolean hasUntypedArguments(ExpressionFunction function) {
return function.arguments().size() > function.argumentTypes().size();
}
private TensorType resolveType(RankingExpression expression, String expressionDescription, TypeContext context) {
if (expression == null) return null;
return resolveType(expression.getRoot(), expressionDescription, context);
}
private TensorType resolveType(ExpressionNode expression, String expressionDescription, TypeContext context) {
TensorType type;
try {
type = expression.type(context);
}
catch (IllegalArgumentException e) {
throw new IllegalArgumentException("The " + expressionDescription + " is invalid", e);
}
if (type == null) // Not expected to happen
throw new IllegalStateException("Could not determine the type produced by " + expressionDescription);
return type;
}
private void ensureValidDouble(RankingExpression expression, String expressionDescription, TypeContext context) {
if (expression == null) return;
TensorType type = resolveType(expression, expressionDescription, context);
if ( ! type.equals(TensorType.empty))
throw new IllegalArgumentException("The " + expressionDescription + " must produce a double " +
"(a tensor with no dimensions), but produces " + type);
}
}
|
