Merge pull request #18093 from vespa-engine/havardpe/explicit-rank-expression-name

use explicit expression name

2 files changed, 15 insertions, 17 deletions

diff --git a/searchlib/src/tests/features/ranking_expression/ranking_expression_test.cpp b/searchlib/src/tests/features/ranking_expression/ranking_expression_test.cpp
index 6baa6581edf..3bc70ee7798 100644
--- a/searchlib/src/tests/features/ranking_expression/ranking_expression_test.cpp
+++ b/searchlib/src/tests/features/ranking_expression/ranking_expression_test.cpp
@@ -68,13 +68,13 @@ struct SetupResult {
     DummyDependencyHandler deps;
     bool setup_ok;
     SetupResult(const TypeMap &object_inputs, const vespalib::string &expression,
-                bool external_expression = false);
+                const vespalib::string &expression_name = "");
     ~SetupResult();
 };
 
 SetupResult::SetupResult(const TypeMap &object_inputs,
                          const vespalib::string &expression,
-                         bool external_expression)
+                         const vespalib::string &expression_name)
     : stash(), index_env(), query_env(&index_env), rank(make_replacer()), deps(rank), setup_ok(false)
 {
     rank.setName("self");
@@ -82,11 +82,11 @@ SetupResult::SetupResult(const TypeMap &object_inputs,
         deps.define_object_input(input.first, ValueType::from_spec(input.second));
     }
     std::vector<vespalib::string> params;
-    if (external_expression) {
-        params.push_back("my_expr");
-        index_env.addRankingExpression("my_expr", expression);
-    } else {
+    if (expression_name.empty()) {
         index_env.getProperties().add("self.rankingScript", expression);
+    } else {
+        index_env.addRankingExpression(expression_name, expression);
+        index_env.getProperties().add("self.expressionName", expression_name);
     }
     Blueprint &bp = rank;
     setup_ok = bp.setup(index_env, params);
@@ -96,9 +96,9 @@ SetupResult::~SetupResult() = default;
 
 void verify_output_type(const TypeMap &object_inputs,
                         const vespalib::string &expression, const FeatureType &expect,
-                        bool external_expression = false)
+                        const vespalib::string &expression_name = "")
 {
-    SetupResult result(object_inputs, expression, external_expression);
+    SetupResult result(object_inputs, expression, expression_name);
     EXPECT_TRUE(result.setup_ok);
     EXPECT_EQUAL(1u, result.deps.output.size());
     ASSERT_EQUAL(1u, result.deps.output_type.size());
@@ -137,10 +137,10 @@ TEST("require that ranking expression can resolve to concrete complex type") {
 }
 
 TEST("require that ranking expression can be external") {
-    TEST_DO(verify_output_type({}, "a*b", FeatureType::number(), true));
-    TEST_DO(verify_output_type({{"b", "double"}}, "a*b", FeatureType::object(ValueType::double_type()), true));
+    TEST_DO(verify_output_type({}, "a*b", FeatureType::number(), "my_expr"));
+    TEST_DO(verify_output_type({{"b", "double"}}, "a*b", FeatureType::object(ValueType::double_type()), "my_expr"));
     TEST_DO(verify_output_type({{"a", "tensor(x{},y{})"}, {"b", "tensor(y{},z{})"}}, "a*b",
-                               FeatureType::object(ValueType::from_spec("tensor(x{},y{},z{})")), true));
+                               FeatureType::object(ValueType::from_spec("tensor(x{},y{},z{})")), "my_expr"));
 }
 
 TEST("require that setup fails for incompatible types") {
diff --git a/searchlib/src/vespa/searchlib/features/rankingexpressionfeature.cpp b/searchlib/src/vespa/searchlib/features/rankingexpressionfeature.cpp
index 070d70997e6..15bd810e597 100644
--- a/searchlib/src/vespa/searchlib/features/rankingexpressionfeature.cpp
+++ b/searchlib/src/vespa/searchlib/features/rankingexpressionfeature.cpp
@@ -244,17 +244,15 @@ RankingExpressionBlueprint::setup(const fef::IIndexEnvironment &env,
     // Retrieve and concatenate whatever config is available.
     vespalib::string script = "";
     fef::Property property = env.getProperties().lookup(getName(), "rankingScript");
+    fef::Property expr_name = env.getProperties().lookup(getName(), "expressionName");
     if (property.size() > 0) {
         for (uint32_t i = 0; i < property.size(); ++i) {
             script.append(property.getAt(i));
         }
-        //LOG(debug, "Script from config: '%s'\n", script.c_str());
+    } else if (expr_name.size() == 1) {
+        script = env.getRankingExpression(expr_name.get());
     } else if (params.size() == 1) {
-        script = env.getRankingExpression(params[0].getValue());
-        if (script.empty()) {
-            script = params[0].getValue();
-        }
-        //LOG(debug, "Script from param: '%s'\n", script.c_str());
+        script = params[0].getValue();
     } else {
         return fail("No expression given.");
     }