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
|
// Copyright Vespa.ai. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
#pragma once
#include "hit.h"
#include "querynode.h"
#include "querynoderesultbase.h"
#include <vespa/searchlib/query/query_term_ucs4.h>
#include <vespa/searchlib/query/weight.h>
#include <vespa/vespalib/objects/objectvisitor.h>
#include <vespa/vespalib/stllike/string.h>
namespace search::streaming {
class NearestNeighborQueryNode;
/**
This is a leaf in the Query tree. All terms are leafs.
A QueryTerm has the index for where to find the term. The term is a string,
both char(utf8) and ucs4. There are flags indicating encoding. And there are
flags indicating if it should be considered a prefix.
*/
class QueryTerm : public QueryTermUCS4, public QueryNode
{
public:
using UP = std::unique_ptr<QueryTerm>;
class EncodingBitMap
{
public:
EncodingBitMap(uint8_t bm=0) : _enc(bm) { }
bool isFloat() const { return _enc & Float; }
bool isBase10Integer() const { return _enc & Base10Integer; }
bool isAscii7Bit() const { return _enc & Ascii7Bit; }
void setBase10Integer(bool v) { if (v) _enc |= Base10Integer; else _enc &= ~Base10Integer; }
void setAscii7Bit(bool v) { if (v) _enc |= Ascii7Bit; else _enc &= ~Ascii7Bit; }
void setFloat(bool v) { if (v) _enc |= Float; else _enc &= ~Float; }
private:
enum { Ascii7Bit=0x01, Base10Integer=0x02, Float=0x04 };
uint8_t _enc;
};
class FieldInfo {
public:
FieldInfo() noexcept : _hitListOffset(0), _hitCount(0), _fieldLength(0) { }
FieldInfo(uint32_t hitListOffset, uint32_t hitCount, uint32_t fieldLength) :
_hitListOffset(hitListOffset), _hitCount(hitCount), _fieldLength(fieldLength) { }
size_t getHitOffset() const { return _hitListOffset; }
size_t getHitCount() const { return _hitCount; }
size_t getFieldLength() const { return _fieldLength; }
FieldInfo & setHitOffset(size_t v) { _hitListOffset = v; return *this; }
FieldInfo & setHitCount(size_t v) { _hitCount = v; return *this; }
FieldInfo & setFieldLength(size_t v) { _fieldLength = v; return *this; }
private:
uint32_t _hitListOffset;
uint32_t _hitCount;
uint32_t _fieldLength;
};
QueryTerm(std::unique_ptr<QueryNodeResultBase> resultBase, const string & term, const string & index, Type type);
QueryTerm(const QueryTerm &) = delete;
QueryTerm & operator = (const QueryTerm &) = delete;
QueryTerm(QueryTerm &&) = delete;
QueryTerm & operator = (QueryTerm &&) = delete;
~QueryTerm() override;
bool evaluate() const override;
const HitList & evaluateHits(HitList & hl) const override;
void reset() override;
void getLeafs(QueryTermList & tl) override;
void getLeafs(ConstQueryTermList & tl) const override;
/// Gives you all phrases of this tree.
void getPhrases(QueryNodeRefList & tl) override;
/// Gives you all phrases of this tree. Indicating that they are all const.
void getPhrases(ConstQueryNodeRefList & tl) const override;
void add(unsigned pos, unsigned context, uint32_t elemId, int32_t weight);
EncodingBitMap encoding() const { return _encoding; }
size_t termLen() const { return getTermLen(); }
const string & index() const { return _index; }
void setWeight(query::Weight v) { _weight = v; }
void setUniqueId(uint32_t u) { _uniqueId = u; }
query::Weight weight() const { return _weight; }
uint32_t uniqueId() const { return _uniqueId; }
void resizeFieldId(size_t fieldId);
const FieldInfo & getFieldInfo(size_t fid) const { return _fieldInfo[fid]; }
FieldInfo & getFieldInfo(size_t fid) { return _fieldInfo[fid]; }
size_t getFieldInfoSize() const { return _fieldInfo.size(); }
QueryNodeResultBase & getQueryItem() { return *_result; }
const HitList & getHitList() const { return _hitList; }
void visitMembers(vespalib::ObjectVisitor &visitor) const override;
void setIndex(const string & index_) override { _index = index_; }
const string & getIndex() const override { return _index; }
void setFuzzyMaxEditDistance(uint32_t fuzzyMaxEditDistance) { _fuzzyMaxEditDistance = fuzzyMaxEditDistance; }
void setFuzzyPrefixLength(uint32_t fuzzyPrefixLength) { _fuzzyPrefixLength = fuzzyPrefixLength; }
virtual NearestNeighborQueryNode* as_nearest_neighbor_query_node() noexcept;
protected:
using QueryNodeResultBaseContainer = std::unique_ptr<QueryNodeResultBase>;
string _index;
EncodingBitMap _encoding;
QueryNodeResultBaseContainer _result;
HitList _hitList;
private:
query::Weight _weight;
uint32_t _uniqueId;
std::vector<FieldInfo> _fieldInfo;
};
}
|
