Introducing fuzzy search

3 files changed, 20 insertions, 2 deletions

diff --git a/searchlib/src/tests/query/customtypevisitor_test.cpp b/searchlib/src/tests/query/customtypevisitor_test.cpp
index 35280fb0bd8..0e8155e23c3 100644
--- a/searchlib/src/tests/query/customtypevisitor_test.cpp
+++ b/searchlib/src/tests/query/customtypevisitor_test.cpp
@@ -36,6 +36,7 @@ struct MyRangeTerm : InitTerm<RangeTerm> {};
 struct MyStringTerm : InitTerm<StringTerm>  {};
 struct MySubstrTerm : InitTerm<SubstringTerm>  {};
 struct MySuffixTerm : InitTerm<SuffixTerm>  {};
+struct MyFuzzyTerm : InitTerm<FuzzyTerm> {};
 struct MyWeakAnd : WeakAnd { MyWeakAnd() : WeakAnd(1234, "view") {} };
 struct MyWeightedSetTerm : WeightedSetTerm { MyWeightedSetTerm() : WeightedSetTerm(0, "view", 0, Weight(42)) {} };
 struct MyDotProduct : DotProduct { MyDotProduct() : DotProduct(0, "view", 0, Weight(42)) {} };
@@ -65,6 +66,7 @@ struct MyQueryNodeTypes {
     typedef MyStringTerm StringTerm;
     typedef MySubstrTerm SubstringTerm;
     typedef MySuffixTerm SuffixTerm;
+    typedef MyFuzzyTerm FuzzyTerm;
     typedef MyWeakAnd WeakAnd;
     typedef MyWeightedSetTerm WeightedSetTerm;
     typedef MyDotProduct DotProduct;
@@ -112,6 +114,7 @@ public:
     void visit(MyNearestNeighborTerm &) override { setVisited<MyNearestNeighborTerm>(); }
     void visit(MyTrue &) override { setVisited<MyTrue>(); }
     void visit(MyFalse &) override { setVisited<MyFalse>(); }
+    void visit(MyFuzzyTerm &) override { setVisited<MyFuzzyTerm>(); }
 };
 
 template <class T>
@@ -148,6 +151,7 @@ TEST("customtypevisitor_test") {
     requireThatNodeIsVisited<MyNearestNeighborTerm>();
     requireThatNodeIsVisited<MyTrue>();
     requireThatNodeIsVisited<MyFalse>();
+    requireThatNodeIsVisited<MyFuzzyTerm>();
 }
 }  // namespace
 
diff --git a/searchlib/src/tests/query/query_visitor_test.cpp b/searchlib/src/tests/query/query_visitor_test.cpp
index 9f73c1ff585..f770213e8e5 100644
--- a/searchlib/src/tests/query/query_visitor_test.cpp
+++ b/searchlib/src/tests/query/query_visitor_test.cpp
@@ -49,6 +49,7 @@ public:
     void visit(NearestNeighborTerm &) override { isVisited<NearestNeighborTerm>() = true; }
     void visit(TrueQueryNode &) override { isVisited<TrueQueryNode>() = true; }
     void visit(FalseQueryNode &) override { isVisited<FalseQueryNode>() = true; }
+    void visit(FuzzyTerm &) override { isVisited<FuzzyTerm>() = true; }
 };
 
 template <class T>
@@ -85,6 +86,7 @@ TEST("requireThatAllNodesCanBeVisited") {
     checkVisit<NearestNeighborTerm>(new SimpleNearestNeighborTerm("query_tensor", "doc_tensor", 0, Weight(0), 123, true, 321, 100100.25));
     checkVisit<TrueQueryNode>(new SimpleTrue());
     checkVisit<FalseQueryNode>(new SimpleFalse());
+    checkVisit<FuzzyTerm>(new SimpleFuzzyTerm("t", "field", 0, Weight(0)));
 }
 
 }  // namespace
diff --git a/searchlib/src/tests/query/querybuilder_test.cpp b/searchlib/src/tests/query/querybuilder_test.cpp
index 93cfad27742..2ea566027c4 100644
--- a/searchlib/src/tests/query/querybuilder_test.cpp
+++ b/searchlib/src/tests/query/querybuilder_test.cpp
@@ -47,7 +47,7 @@ PredicateQueryTerm::UP getPredicateQueryTerm() {
 template <class NodeTypes>
 Node::UP createQueryTree() {
     QueryBuilder<NodeTypes> builder;
-    builder.addAnd(12);
+    builder.addAnd(13);
     {
         builder.addRank(2);
         {
@@ -115,6 +115,7 @@ Node::UP createQueryTree() {
             builder.add_true_node();
             builder.add_false_node();
         }
+        builder.addFuzzyTerm(str[5], view[5], id[5], weight[5]);
     }
     Node::UP node = builder.build();
     ASSERT_TRUE(node.get());
@@ -179,10 +180,11 @@ void checkQueryTreeTypes(Node *node) {
     typedef typename NodeTypes::RegExpTerm RegExpTerm;
     typedef typename NodeTypes::TrueQueryNode TrueNode;
     typedef typename NodeTypes::FalseQueryNode FalseNode;
+    typedef typename NodeTypes::FuzzyTerm FuzzyTerm;
 
     ASSERT_TRUE(node);
     auto* and_node = as_node<And>(node);
-    EXPECT_EQUAL(12u, and_node->getChildren().size());
+    EXPECT_EQUAL(13u, and_node->getChildren().size());
 
     auto* rank = as_node<Rank>(and_node->getChildren()[0]);
     EXPECT_EQUAL(2u, rank->getChildren().size());
@@ -306,6 +308,9 @@ void checkQueryTreeTypes(Node *node) {
     auto* false_node = as_node<FalseNode>(and_not->getChildren()[1]);
     EXPECT_TRUE(true_node);
     EXPECT_TRUE(false_node);
+
+    auto* fuzzy_term = as_node<FuzzyTerm>(and_node->getChildren()[12]);
+    EXPECT_TRUE(checkTerm(fuzzy_term, str[5], view[5], id[5], weight[5]));
 }
 
 struct AbstractTypes {
@@ -332,6 +337,7 @@ struct AbstractTypes {
     typedef search::query::RegExpTerm RegExpTerm;
     typedef search::query::TrueQueryNode TrueQueryNode;
     typedef search::query::FalseQueryNode FalseQueryNode;
+    typedef search::query::FuzzyTerm FuzzyTerm;
 };
 
 // Builds a tree with simplequery and checks that the results have the
@@ -427,6 +433,11 @@ struct MyNearestNeighborTerm : NearestNeighborTerm {
 };
 struct MyTrue : TrueQueryNode {};
 struct MyFalse : FalseQueryNode {};
+struct MyFuzzyTerm : FuzzyTerm {
+    MyFuzzyTerm(const Type &t, const string &f, int32_t i, Weight w)
+            : FuzzyTerm(t, f, i, w) {
+    }
+};
 
 struct MyQueryNodeTypes {
     typedef MyAnd And;
@@ -454,6 +465,7 @@ struct MyQueryNodeTypes {
     typedef MyNearestNeighborTerm NearestNeighborTerm;
     typedef MyTrue TrueQueryNode;
     typedef MyFalse FalseQueryNode;
+    typedef MyFuzzyTerm FuzzyTerm;
 };
 
 TEST("require that Custom Query Trees Can Be Built") {