Update bleve dependency to latest master revision (#6100)
* update bleve to master b17287a86f6cac923a5d886e10618df994eeb54b6724eac2e3b8dde89cfbe3a2 * remove unused pkg from dep file * change bleve from master to recent revisiontokarchuk/v1.17
Lunny Xiao
6 years ago
committed by
techknowlogick
parent
11e316654e
commit
a380cfd8e0
@ -1,22 +0,0 @@ |
|||||||
The MIT License (MIT) |
|
||||||
|
|
||||||
Copyright (c) 2015 Stephen Merity |
|
||||||
|
|
||||||
Permission is hereby granted, free of charge, to any person obtaining a copy |
|
||||||
of this software and associated documentation files (the "Software"), to deal |
|
||||||
in the Software without restriction, including without limitation the rights |
|
||||||
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell |
|
||||||
copies of the Software, and to permit persons to whom the Software is |
|
||||||
furnished to do so, subject to the following conditions: |
|
||||||
|
|
||||||
The above copyright notice and this permission notice shall be included in all |
|
||||||
copies or substantial portions of the Software. |
|
||||||
|
|
||||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
|
||||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
|
||||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
|
||||||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
|
||||||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, |
|
||||||
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE |
|
||||||
SOFTWARE. |
|
||||||
|
|
||||||
@ -1,229 +0,0 @@ |
|||||||
package govarint |
|
||||||
|
|
||||||
import "encoding/binary" |
|
||||||
import "io" |
|
||||||
|
|
||||||
type U32VarintEncoder interface { |
|
||||||
PutU32(x uint32) int |
|
||||||
Close() |
|
||||||
} |
|
||||||
|
|
||||||
type U32VarintDecoder interface { |
|
||||||
GetU32() (uint32, error) |
|
||||||
} |
|
||||||
|
|
||||||
///
|
|
||||||
|
|
||||||
type U64VarintEncoder interface { |
|
||||||
PutU64(x uint64) int |
|
||||||
Close() |
|
||||||
} |
|
||||||
|
|
||||||
type U64VarintDecoder interface { |
|
||||||
GetU64() (uint64, error) |
|
||||||
} |
|
||||||
|
|
||||||
///
|
|
||||||
|
|
||||||
type U32GroupVarintEncoder struct { |
|
||||||
w io.Writer |
|
||||||
index int |
|
||||||
store [4]uint32 |
|
||||||
temp [17]byte |
|
||||||
} |
|
||||||
|
|
||||||
func NewU32GroupVarintEncoder(w io.Writer) *U32GroupVarintEncoder { return &U32GroupVarintEncoder{w: w} } |
|
||||||
|
|
||||||
func (b *U32GroupVarintEncoder) Flush() (int, error) { |
|
||||||
// TODO: Is it more efficient to have a tailored version that's called only in Close()?
|
|
||||||
// If index is zero, there are no integers to flush
|
|
||||||
if b.index == 0 { |
|
||||||
return 0, nil |
|
||||||
} |
|
||||||
// In the case we're flushing (the group isn't of size four), the non-values should be zero
|
|
||||||
// This ensures the unused entries are all zero in the sizeByte
|
|
||||||
for i := b.index; i < 4; i++ { |
|
||||||
b.store[i] = 0 |
|
||||||
} |
|
||||||
length := 1 |
|
||||||
// We need to reset the size byte to zero as we only bitwise OR into it, we don't overwrite it
|
|
||||||
b.temp[0] = 0 |
|
||||||
for i, x := range b.store { |
|
||||||
size := byte(0) |
|
||||||
shifts := []byte{24, 16, 8, 0} |
|
||||||
for _, shift := range shifts { |
|
||||||
// Always writes at least one byte -- the first one (shift = 0)
|
|
||||||
// Will write more bytes until the rest of the integer is all zeroes
|
|
||||||
if (x>>shift) != 0 || shift == 0 { |
|
||||||
size += 1 |
|
||||||
b.temp[length] = byte(x >> shift) |
|
||||||
length += 1 |
|
||||||
} |
|
||||||
} |
|
||||||
// We store the size in two of the eight bits in the first byte (sizeByte)
|
|
||||||
// 0 means there is one byte in total, hence why we subtract one from size
|
|
||||||
b.temp[0] |= (size - 1) << (uint8(3-i) * 2) |
|
||||||
} |
|
||||||
// If we're flushing without a full group of four, remove the unused bytes we computed
|
|
||||||
// This enables us to realize it's a partial group on decoding thanks to EOF
|
|
||||||
if b.index != 4 { |
|
||||||
length -= 4 - b.index |
|
||||||
} |
|
||||||
_, err := b.w.Write(b.temp[:length]) |
|
||||||
return length, err |
|
||||||
} |
|
||||||
|
|
||||||
func (b *U32GroupVarintEncoder) PutU32(x uint32) (int, error) { |
|
||||||
bytesWritten := 0 |
|
||||||
b.store[b.index] = x |
|
||||||
b.index += 1 |
|
||||||
if b.index == 4 { |
|
||||||
n, err := b.Flush() |
|
||||||
if err != nil { |
|
||||||
return n, err |
|
||||||
} |
|
||||||
bytesWritten += n |
|
||||||
b.index = 0 |
|
||||||
} |
|
||||||
return bytesWritten, nil |
|
||||||
} |
|
||||||
|
|
||||||
func (b *U32GroupVarintEncoder) Close() { |
|
||||||
// On Close, we flush any remaining values that might not have been in a full group
|
|
||||||
b.Flush() |
|
||||||
} |
|
||||||
|
|
||||||
///
|
|
||||||
|
|
||||||
type U32GroupVarintDecoder struct { |
|
||||||
r io.ByteReader |
|
||||||
group [4]uint32 |
|
||||||
pos int |
|
||||||
finished bool |
|
||||||
capacity int |
|
||||||
} |
|
||||||
|
|
||||||
func NewU32GroupVarintDecoder(r io.ByteReader) *U32GroupVarintDecoder { |
|
||||||
return &U32GroupVarintDecoder{r: r, pos: 4, capacity: 4} |
|
||||||
} |
|
||||||
|
|
||||||
func (b *U32GroupVarintDecoder) getGroup() error { |
|
||||||
// We should always receive a sizeByte if there are more values to read
|
|
||||||
sizeByte, err := b.r.ReadByte() |
|
||||||
if err != nil { |
|
||||||
return err |
|
||||||
} |
|
||||||
// Calculate the size of the four incoming 32 bit integers
|
|
||||||
// 0b00 means 1 byte to read, 0b01 = 2, etc
|
|
||||||
b.group[0] = uint32((sizeByte >> 6) & 3) |
|
||||||
b.group[1] = uint32((sizeByte >> 4) & 3) |
|
||||||
b.group[2] = uint32((sizeByte >> 2) & 3) |
|
||||||
b.group[3] = uint32(sizeByte & 3) |
|
||||||
//
|
|
||||||
for index, size := range b.group { |
|
||||||
b.group[index] = 0 |
|
||||||
// Any error that occurs in earlier byte reads should be repeated at the end one
|
|
||||||
// Hence we only catch and report the final ReadByte's error
|
|
||||||
var err error |
|
||||||
switch size { |
|
||||||
case 0: |
|
||||||
var x byte |
|
||||||
x, err = b.r.ReadByte() |
|
||||||
b.group[index] = uint32(x) |
|
||||||
case 1: |
|
||||||
var x, y byte |
|
||||||
x, _ = b.r.ReadByte() |
|
||||||
y, err = b.r.ReadByte() |
|
||||||
b.group[index] = uint32(x)<<8 | uint32(y) |
|
||||||
case 2: |
|
||||||
var x, y, z byte |
|
||||||
x, _ = b.r.ReadByte() |
|
||||||
y, _ = b.r.ReadByte() |
|
||||||
z, err = b.r.ReadByte() |
|
||||||
b.group[index] = uint32(x)<<16 | uint32(y)<<8 | uint32(z) |
|
||||||
case 3: |
|
||||||
var x, y, z, zz byte |
|
||||||
x, _ = b.r.ReadByte() |
|
||||||
y, _ = b.r.ReadByte() |
|
||||||
z, _ = b.r.ReadByte() |
|
||||||
zz, err = b.r.ReadByte() |
|
||||||
b.group[index] = uint32(x)<<24 | uint32(y)<<16 | uint32(z)<<8 | uint32(zz) |
|
||||||
} |
|
||||||
if err != nil { |
|
||||||
if err == io.EOF { |
|
||||||
// If we hit EOF here, we have found a partial group
|
|
||||||
// We've return any valid entries we have read and return EOF once we run out
|
|
||||||
b.capacity = index |
|
||||||
b.finished = true |
|
||||||
break |
|
||||||
} else { |
|
||||||
return err |
|
||||||
} |
|
||||||
} |
|
||||||
} |
|
||||||
// Reset the pos pointer to the beginning of the read values
|
|
||||||
b.pos = 0 |
|
||||||
return nil |
|
||||||
} |
|
||||||
|
|
||||||
func (b *U32GroupVarintDecoder) GetU32() (uint32, error) { |
|
||||||
// Check if we have any more values to give out - if not, let's get them
|
|
||||||
if b.pos == b.capacity { |
|
||||||
// If finished is set, there is nothing else to do
|
|
||||||
if b.finished { |
|
||||||
return 0, io.EOF |
|
||||||
} |
|
||||||
err := b.getGroup() |
|
||||||
if err != nil { |
|
||||||
return 0, err |
|
||||||
} |
|
||||||
} |
|
||||||
// Increment pointer and return the value stored at that point
|
|
||||||
b.pos += 1 |
|
||||||
return b.group[b.pos-1], nil |
|
||||||
} |
|
||||||
|
|
||||||
///
|
|
||||||
|
|
||||||
type Base128Encoder struct { |
|
||||||
w io.Writer |
|
||||||
tmpBytes []byte |
|
||||||
} |
|
||||||
|
|
||||||
func NewU32Base128Encoder(w io.Writer) *Base128Encoder { |
|
||||||
return &Base128Encoder{w: w, tmpBytes: make([]byte, binary.MaxVarintLen32)} |
|
||||||
} |
|
||||||
func NewU64Base128Encoder(w io.Writer) *Base128Encoder { |
|
||||||
return &Base128Encoder{w: w, tmpBytes: make([]byte, binary.MaxVarintLen64)} |
|
||||||
} |
|
||||||
|
|
||||||
func (b *Base128Encoder) PutU32(x uint32) (int, error) { |
|
||||||
writtenBytes := binary.PutUvarint(b.tmpBytes, uint64(x)) |
|
||||||
return b.w.Write(b.tmpBytes[:writtenBytes]) |
|
||||||
} |
|
||||||
|
|
||||||
func (b *Base128Encoder) PutU64(x uint64) (int, error) { |
|
||||||
writtenBytes := binary.PutUvarint(b.tmpBytes, x) |
|
||||||
return b.w.Write(b.tmpBytes[:writtenBytes]) |
|
||||||
} |
|
||||||
|
|
||||||
func (b *Base128Encoder) Close() { |
|
||||||
} |
|
||||||
|
|
||||||
///
|
|
||||||
|
|
||||||
type Base128Decoder struct { |
|
||||||
r io.ByteReader |
|
||||||
} |
|
||||||
|
|
||||||
func NewU32Base128Decoder(r io.ByteReader) *Base128Decoder { return &Base128Decoder{r: r} } |
|
||||||
func NewU64Base128Decoder(r io.ByteReader) *Base128Decoder { return &Base128Decoder{r: r} } |
|
||||||
|
|
||||||
func (b *Base128Decoder) GetU32() (uint32, error) { |
|
||||||
v, err := binary.ReadUvarint(b.r) |
|
||||||
return uint32(v), err |
|
||||||
} |
|
||||||
|
|
||||||
func (b *Base128Decoder) GetU64() (uint64, error) { |
|
||||||
return binary.ReadUvarint(b.r) |
|
||||||
} |
|
||||||
@ -0,0 +1,174 @@ |
|||||||
|
// The code here was obtained from:
|
||||||
|
// https://github.com/mmcloughlin/geohash
|
||||||
|
|
||||||
|
// The MIT License (MIT)
|
||||||
|
// Copyright (c) 2015 Michael McLoughlin
|
||||||
|
// Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||||
|
// of this software and associated documentation files (the "Software"), to deal
|
||||||
|
// in the Software without restriction, including without limitation the rights
|
||||||
|
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||||
|
// copies of the Software, and to permit persons to whom the Software is
|
||||||
|
// furnished to do so, subject to the following conditions:
|
||||||
|
|
||||||
|
// The above copyright notice and this permission notice shall be included in all
|
||||||
|
// copies or substantial portions of the Software.
|
||||||
|
|
||||||
|
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||||
|
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||||
|
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||||
|
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||||
|
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||||
|
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||||
|
// SOFTWARE.
|
||||||
|
|
||||||
|
package geo |
||||||
|
|
||||||
|
import ( |
||||||
|
"math" |
||||||
|
) |
||||||
|
|
||||||
|
// encoding encapsulates an encoding defined by a given base32 alphabet.
|
||||||
|
type encoding struct { |
||||||
|
enc string |
||||||
|
dec [256]byte |
||||||
|
} |
||||||
|
|
||||||
|
// newEncoding constructs a new encoding defined by the given alphabet,
|
||||||
|
// which must be a 32-byte string.
|
||||||
|
func newEncoding(encoder string) *encoding { |
||||||
|
e := new(encoding) |
||||||
|
e.enc = encoder |
||||||
|
for i := 0; i < len(e.dec); i++ { |
||||||
|
e.dec[i] = 0xff |
||||||
|
} |
||||||
|
for i := 0; i < len(encoder); i++ { |
||||||
|
e.dec[encoder[i]] = byte(i) |
||||||
|
} |
||||||
|
return e |
||||||
|
} |
||||||
|
|
||||||
|
// Decode string into bits of a 64-bit word. The string s may be at most 12
|
||||||
|
// characters.
|
||||||
|
func (e *encoding) decode(s string) uint64 { |
||||||
|
x := uint64(0) |
||||||
|
for i := 0; i < len(s); i++ { |
||||||
|
x = (x << 5) | uint64(e.dec[s[i]]) |
||||||
|
} |
||||||
|
return x |
||||||
|
} |
||||||
|
|
||||||
|
// Encode bits of 64-bit word into a string.
|
||||||
|
func (e *encoding) encode(x uint64) string { |
||||||
|
b := [12]byte{} |
||||||
|
for i := 0; i < 12; i++ { |
||||||
|
b[11-i] = e.enc[x&0x1f] |
||||||
|
x >>= 5 |
||||||
|
} |
||||||
|
return string(b[:]) |
||||||
|
} |
||||||
|
|
||||||
|
// Base32Encoding with the Geohash alphabet.
|
||||||
|
var base32encoding = newEncoding("0123456789bcdefghjkmnpqrstuvwxyz") |
||||||
|
|
||||||
|
// BoundingBox returns the region encoded by the given string geohash.
|
||||||
|
func geoBoundingBox(hash string) geoBox { |
||||||
|
bits := uint(5 * len(hash)) |
||||||
|
inthash := base32encoding.decode(hash) |
||||||
|
return geoBoundingBoxIntWithPrecision(inthash, bits) |
||||||
|
} |
||||||
|
|
||||||
|
// Box represents a rectangle in latitude/longitude space.
|
||||||
|
type geoBox struct { |
||||||
|
minLat float64 |
||||||
|
maxLat float64 |
||||||
|
minLng float64 |
||||||
|
maxLng float64 |
||||||
|
} |
||||||
|
|
||||||
|
// Round returns a point inside the box, making an effort to round to minimal
|
||||||
|
// precision.
|
||||||
|
func (b geoBox) round() (lat, lng float64) { |
||||||
|
x := maxDecimalPower(b.maxLat - b.minLat) |
||||||
|
lat = math.Ceil(b.minLat/x) * x |
||||||
|
x = maxDecimalPower(b.maxLng - b.minLng) |
||||||
|
lng = math.Ceil(b.minLng/x) * x |
||||||
|
return |
||||||
|
} |
||||||
|
|
||||||
|
// precalculated for performance
|
||||||
|
var exp232 = math.Exp2(32) |
||||||
|
|
||||||
|
// errorWithPrecision returns the error range in latitude and longitude for in
|
||||||
|
// integer geohash with bits of precision.
|
||||||
|
func errorWithPrecision(bits uint) (latErr, lngErr float64) { |
||||||
|
b := int(bits) |
||||||
|
latBits := b / 2 |
||||||
|
lngBits := b - latBits |
||||||
|
latErr = math.Ldexp(180.0, -latBits) |
||||||
|
lngErr = math.Ldexp(360.0, -lngBits) |
||||||
|
return |
||||||
|
} |
||||||
|
|
||||||
|
// minDecimalPlaces returns the minimum number of decimal places such that
|
||||||
|
// there must exist an number with that many places within any range of width
|
||||||
|
// r. This is intended for returning minimal precision coordinates inside a
|
||||||
|
// box.
|
||||||
|
func maxDecimalPower(r float64) float64 { |
||||||
|
m := int(math.Floor(math.Log10(r))) |
||||||
|
return math.Pow10(m) |
||||||
|
} |
||||||
|
|
||||||
|
// Encode the position of x within the range -r to +r as a 32-bit integer.
|
||||||
|
func encodeRange(x, r float64) uint32 { |
||||||
|
p := (x + r) / (2 * r) |
||||||
|
return uint32(p * exp232) |
||||||
|
} |
||||||
|
|
||||||
|
// Decode the 32-bit range encoding X back to a value in the range -r to +r.
|
||||||
|
func decodeRange(X uint32, r float64) float64 { |
||||||
|
p := float64(X) / exp232 |
||||||
|
x := 2*r*p - r |
||||||
|
return x |
||||||
|
} |
||||||
|
|
||||||
|
// Squash the even bitlevels of X into a 32-bit word. Odd bitlevels of X are
|
||||||
|
// ignored, and may take any value.
|
||||||
|
func squash(X uint64) uint32 { |
||||||
|
X &= 0x5555555555555555 |
||||||
|
X = (X | (X >> 1)) & 0x3333333333333333 |
||||||
|
X = (X | (X >> 2)) & 0x0f0f0f0f0f0f0f0f |
||||||
|
X = (X | (X >> 4)) & 0x00ff00ff00ff00ff |
||||||
|
X = (X | (X >> 8)) & 0x0000ffff0000ffff |
||||||
|
X = (X | (X >> 16)) & 0x00000000ffffffff |
||||||
|
return uint32(X) |
||||||
|
} |
||||||
|
|
||||||
|
// Deinterleave the bits of X into 32-bit words containing the even and odd
|
||||||
|
// bitlevels of X, respectively.
|
||||||
|
func deinterleave(X uint64) (uint32, uint32) { |
||||||
|
return squash(X), squash(X >> 1) |
||||||
|
} |
||||||
|
|
||||||
|
// BoundingBoxIntWithPrecision returns the region encoded by the integer
|
||||||
|
// geohash with the specified precision.
|
||||||
|
func geoBoundingBoxIntWithPrecision(hash uint64, bits uint) geoBox { |
||||||
|
fullHash := hash << (64 - bits) |
||||||
|
latInt, lngInt := deinterleave(fullHash) |
||||||
|
lat := decodeRange(latInt, 90) |
||||||
|
lng := decodeRange(lngInt, 180) |
||||||
|
latErr, lngErr := errorWithPrecision(bits) |
||||||
|
return geoBox{ |
||||||
|
minLat: lat, |
||||||
|
maxLat: lat + latErr, |
||||||
|
minLng: lng, |
||||||
|
maxLng: lng + lngErr, |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
// ----------------------------------------------------------------------
|
||||||
|
|
||||||
|
// Decode the string geohash to a (lat, lng) point.
|
||||||
|
func GeoHashDecode(hash string) (lat, lng float64) { |
||||||
|
box := geoBoundingBox(hash) |
||||||
|
return box.round() |
||||||
|
} |
||||||
@ -0,0 +1,420 @@ |
|||||||
|
// Copyright (c) 2018 Couchbase, Inc.
|
||||||
|
//
|
||||||
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||||
|
// you may not use this file except in compliance with the License.
|
||||||
|
// You may obtain a copy of the License at
|
||||||
|
//
|
||||||
|
// http://www.apache.org/licenses/LICENSE-2.0
|
||||||
|
//
|
||||||
|
// Unless required by applicable law or agreed to in writing, software
|
||||||
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||||
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||||
|
// See the License for the specific language governing permissions and
|
||||||
|
// limitations under the License.
|
||||||
|
|
||||||
|
package scorch |
||||||
|
|
||||||
|
import ( |
||||||
|
"fmt" |
||||||
|
|
||||||
|
"github.com/RoaringBitmap/roaring" |
||||||
|
|
||||||
|
"github.com/blevesearch/bleve/index" |
||||||
|
"github.com/blevesearch/bleve/index/scorch/segment" |
||||||
|
"github.com/blevesearch/bleve/index/scorch/segment/zap" |
||||||
|
) |
||||||
|
|
||||||
|
var OptimizeConjunction = true |
||||||
|
var OptimizeConjunctionUnadorned = true |
||||||
|
var OptimizeDisjunctionUnadorned = true |
||||||
|
|
||||||
|
func (s *IndexSnapshotTermFieldReader) Optimize(kind string, |
||||||
|
octx index.OptimizableContext) (index.OptimizableContext, error) { |
||||||
|
if OptimizeConjunction && kind == "conjunction" { |
||||||
|
return s.optimizeConjunction(octx) |
||||||
|
} |
||||||
|
|
||||||
|
if OptimizeConjunctionUnadorned && kind == "conjunction:unadorned" { |
||||||
|
return s.optimizeConjunctionUnadorned(octx) |
||||||
|
} |
||||||
|
|
||||||
|
if OptimizeDisjunctionUnadorned && kind == "disjunction:unadorned" { |
||||||
|
return s.optimizeDisjunctionUnadorned(octx) |
||||||
|
} |
||||||
|
|
||||||
|
return octx, nil |
||||||
|
} |
||||||
|
|
||||||
|
var OptimizeDisjunctionUnadornedMinChildCardinality = uint64(256) |
||||||
|
|
||||||
|
// ----------------------------------------------------------------
|
||||||
|
|
||||||
|
func (s *IndexSnapshotTermFieldReader) optimizeConjunction( |
||||||
|
octx index.OptimizableContext) (index.OptimizableContext, error) { |
||||||
|
if octx == nil { |
||||||
|
octx = &OptimizeTFRConjunction{snapshot: s.snapshot} |
||||||
|
} |
||||||
|
|
||||||
|
o, ok := octx.(*OptimizeTFRConjunction) |
||||||
|
if !ok { |
||||||
|
return octx, nil |
||||||
|
} |
||||||
|
|
||||||
|
if o.snapshot != s.snapshot { |
||||||
|
return nil, fmt.Errorf("tried to optimize conjunction across different snapshots") |
||||||
|
} |
||||||
|
|
||||||
|
o.tfrs = append(o.tfrs, s) |
||||||
|
|
||||||
|
return o, nil |
||||||
|
} |
||||||
|
|
||||||
|
type OptimizeTFRConjunction struct { |
||||||
|
snapshot *IndexSnapshot |
||||||
|
|
||||||
|
tfrs []*IndexSnapshotTermFieldReader |
||||||
|
} |
||||||
|
|
||||||
|
func (o *OptimizeTFRConjunction) Finish() (index.Optimized, error) { |
||||||
|
if len(o.tfrs) <= 1 { |
||||||
|
return nil, nil |
||||||
|
} |
||||||
|
|
||||||
|
for i := range o.snapshot.segment { |
||||||
|
itr0, ok := o.tfrs[0].iterators[i].(*zap.PostingsIterator) |
||||||
|
if !ok || itr0.ActualBM == nil { |
||||||
|
continue |
||||||
|
} |
||||||
|
|
||||||
|
itr1, ok := o.tfrs[1].iterators[i].(*zap.PostingsIterator) |
||||||
|
if !ok || itr1.ActualBM == nil { |
||||||
|
continue |
||||||
|
} |
||||||
|
|
||||||
|
bm := roaring.And(itr0.ActualBM, itr1.ActualBM) |
||||||
|
|
||||||
|
for _, tfr := range o.tfrs[2:] { |
||||||
|
itr, ok := tfr.iterators[i].(*zap.PostingsIterator) |
||||||
|
if !ok || itr.ActualBM == nil { |
||||||
|
continue |
||||||
|
} |
||||||
|
|
||||||
|
bm.And(itr.ActualBM) |
||||||
|
} |
||||||
|
|
||||||
|
// in this conjunction optimization, the postings iterators
|
||||||
|
// will all share the same AND'ed together actual bitmap. The
|
||||||
|
// regular conjunction searcher machinery will still be used,
|
||||||
|
// but the underlying bitmap will be smaller.
|
||||||
|
for _, tfr := range o.tfrs { |
||||||
|
itr, ok := tfr.iterators[i].(*zap.PostingsIterator) |
||||||
|
if ok && itr.ActualBM != nil { |
||||||
|
itr.ActualBM = bm |
||||||
|
itr.Actual = bm.Iterator() |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
return nil, nil |
||||||
|
} |
||||||
|
|
||||||
|
// ----------------------------------------------------------------
|
||||||
|
|
||||||
|
// An "unadorned" conjunction optimization is appropriate when
|
||||||
|
// additional or subsidiary information like freq-norm's and
|
||||||
|
// term-vectors are not required, and instead only the internal-id's
|
||||||
|
// are needed.
|
||||||
|
func (s *IndexSnapshotTermFieldReader) optimizeConjunctionUnadorned( |
||||||
|
octx index.OptimizableContext) (index.OptimizableContext, error) { |
||||||
|
if octx == nil { |
||||||
|
octx = &OptimizeTFRConjunctionUnadorned{snapshot: s.snapshot} |
||||||
|
} |
||||||
|
|
||||||
|
o, ok := octx.(*OptimizeTFRConjunctionUnadorned) |
||||||
|
if !ok { |
||||||
|
return nil, nil |
||||||
|
} |
||||||
|
|
||||||
|
if o.snapshot != s.snapshot { |
||||||
|
return nil, fmt.Errorf("tried to optimize unadorned conjunction across different snapshots") |
||||||
|
} |
||||||
|
|
||||||
|
o.tfrs = append(o.tfrs, s) |
||||||
|
|
||||||
|
return o, nil |
||||||
|
} |
||||||
|
|
||||||
|
type OptimizeTFRConjunctionUnadorned struct { |
||||||
|
snapshot *IndexSnapshot |
||||||
|
|
||||||
|
tfrs []*IndexSnapshotTermFieldReader |
||||||
|
} |
||||||
|
|
||||||
|
var OptimizeTFRConjunctionUnadornedTerm = []byte("<conjunction:unadorned>") |
||||||
|
var OptimizeTFRConjunctionUnadornedField = "*" |
||||||
|
|
||||||
|
// Finish of an unadorned conjunction optimization will compute a
|
||||||
|
// termFieldReader with an "actual" bitmap that represents the
|
||||||
|
// constituent bitmaps AND'ed together. This termFieldReader cannot
|
||||||
|
// provide any freq-norm or termVector associated information.
|
||||||
|
func (o *OptimizeTFRConjunctionUnadorned) Finish() (rv index.Optimized, err error) { |
||||||
|
if len(o.tfrs) <= 1 { |
||||||
|
return nil, nil |
||||||
|
} |
||||||
|
|
||||||
|
// We use an artificial term and field because the optimized
|
||||||
|
// termFieldReader can represent multiple terms and fields.
|
||||||
|
oTFR := &IndexSnapshotTermFieldReader{ |
||||||
|
term: OptimizeTFRConjunctionUnadornedTerm, |
||||||
|
field: OptimizeTFRConjunctionUnadornedField, |
||||||
|
snapshot: o.snapshot, |
||||||
|
iterators: make([]segment.PostingsIterator, len(o.snapshot.segment)), |
||||||
|
segmentOffset: 0, |
||||||
|
includeFreq: false, |
||||||
|
includeNorm: false, |
||||||
|
includeTermVectors: false, |
||||||
|
} |
||||||
|
|
||||||
|
var actualBMs []*roaring.Bitmap // Collected from regular posting lists.
|
||||||
|
|
||||||
|
OUTER: |
||||||
|
for i := range o.snapshot.segment { |
||||||
|
actualBMs = actualBMs[:0] |
||||||
|
|
||||||
|
var docNum1HitLast uint64 |
||||||
|
var docNum1HitLastOk bool |
||||||
|
|
||||||
|
for _, tfr := range o.tfrs { |
||||||
|
if _, ok := tfr.iterators[i].(*segment.EmptyPostingsIterator); ok { |
||||||
|
// An empty postings iterator means the entire AND is empty.
|
||||||
|
oTFR.iterators[i] = segment.AnEmptyPostingsIterator |
||||||
|
continue OUTER |
||||||
|
} |
||||||
|
|
||||||
|
itr, ok := tfr.iterators[i].(*zap.PostingsIterator) |
||||||
|
if !ok { |
||||||
|
// We optimize zap postings iterators only.
|
||||||
|
return nil, nil |
||||||
|
} |
||||||
|
|
||||||
|
// If the postings iterator is "1-hit" optimized, then we
|
||||||
|
// can perform several optimizations up-front here.
|
||||||
|
docNum1Hit, ok := itr.DocNum1Hit() |
||||||
|
if ok { |
||||||
|
if docNum1Hit == zap.DocNum1HitFinished { |
||||||
|
// An empty docNum here means the entire AND is empty.
|
||||||
|
oTFR.iterators[i] = segment.AnEmptyPostingsIterator |
||||||
|
continue OUTER |
||||||
|
} |
||||||
|
|
||||||
|
if docNum1HitLastOk && docNum1HitLast != docNum1Hit { |
||||||
|
// The docNum1Hit doesn't match the previous
|
||||||
|
// docNum1HitLast, so the entire AND is empty.
|
||||||
|
oTFR.iterators[i] = segment.AnEmptyPostingsIterator |
||||||
|
continue OUTER |
||||||
|
} |
||||||
|
|
||||||
|
docNum1HitLast = docNum1Hit |
||||||
|
docNum1HitLastOk = true |
||||||
|
|
||||||
|
continue |
||||||
|
} |
||||||
|
|
||||||
|
if itr.ActualBM == nil { |
||||||
|
// An empty actual bitmap means the entire AND is empty.
|
||||||
|
oTFR.iterators[i] = segment.AnEmptyPostingsIterator |
||||||
|
continue OUTER |
||||||
|
} |
||||||
|
|
||||||
|
// Collect the actual bitmap for more processing later.
|
||||||
|
actualBMs = append(actualBMs, itr.ActualBM) |
||||||
|
} |
||||||
|
|
||||||
|
if docNum1HitLastOk { |
||||||
|
// We reach here if all the 1-hit optimized posting
|
||||||
|
// iterators had the same 1-hit docNum, so we can check if
|
||||||
|
// our collected actual bitmaps also have that docNum.
|
||||||
|
for _, bm := range actualBMs { |
||||||
|
if !bm.Contains(uint32(docNum1HitLast)) { |
||||||
|
// The docNum1Hit isn't in one of our actual
|
||||||
|
// bitmaps, so the entire AND is empty.
|
||||||
|
oTFR.iterators[i] = segment.AnEmptyPostingsIterator |
||||||
|
continue OUTER |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
// The actual bitmaps and docNum1Hits all contain or have
|
||||||
|
// the same 1-hit docNum, so that's our AND'ed result.
|
||||||
|
oTFR.iterators[i], err = zap.PostingsIteratorFrom1Hit( |
||||||
|
docNum1HitLast, zap.NormBits1Hit, false, false) |
||||||
|
if err != nil { |
||||||
|
return nil, nil |
||||||
|
} |
||||||
|
|
||||||
|
continue OUTER |
||||||
|
} |
||||||
|
|
||||||
|
if len(actualBMs) == 0 { |
||||||
|
// If we've collected no actual bitmaps at this point,
|
||||||
|
// then the entire AND is empty.
|
||||||
|
oTFR.iterators[i] = segment.AnEmptyPostingsIterator |
||||||
|
continue OUTER |
||||||
|
} |
||||||
|
|
||||||
|
if len(actualBMs) == 1 { |
||||||
|
// If we've only 1 actual bitmap, then that's our result.
|
||||||
|
oTFR.iterators[i], err = zap.PostingsIteratorFromBitmap( |
||||||
|
actualBMs[0], false, false) |
||||||
|
if err != nil { |
||||||
|
return nil, nil |
||||||
|
} |
||||||
|
|
||||||
|
continue OUTER |
||||||
|
} |
||||||
|
|
||||||
|
// Else, AND together our collected bitmaps as our result.
|
||||||
|
bm := roaring.And(actualBMs[0], actualBMs[1]) |
||||||
|
|
||||||
|
for _, actualBM := range actualBMs[2:] { |
||||||
|
bm.And(actualBM) |
||||||
|
} |
||||||
|
|
||||||
|
oTFR.iterators[i], err = zap.PostingsIteratorFromBitmap( |
||||||
|
bm, false, false) |
||||||
|
if err != nil { |
||||||
|
return nil, nil |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
return oTFR, nil |
||||||
|
} |
||||||
|
|
||||||
|
// ----------------------------------------------------------------
|
||||||
|
|
||||||
|
// An "unadorned" disjunction optimization is appropriate when
|
||||||
|
// additional or subsidiary information like freq-norm's and
|
||||||
|
// term-vectors are not required, and instead only the internal-id's
|
||||||
|
// are needed.
|
||||||
|
func (s *IndexSnapshotTermFieldReader) optimizeDisjunctionUnadorned( |
||||||
|
octx index.OptimizableContext) (index.OptimizableContext, error) { |
||||||
|
if octx == nil { |
||||||
|
octx = &OptimizeTFRDisjunctionUnadorned{snapshot: s.snapshot} |
||||||
|
} |
||||||
|
|
||||||
|
o, ok := octx.(*OptimizeTFRDisjunctionUnadorned) |
||||||
|
if !ok { |
||||||
|
return nil, nil |
||||||
|
} |
||||||
|
|
||||||
|
if o.snapshot != s.snapshot { |
||||||
|
return nil, fmt.Errorf("tried to optimize unadorned disjunction across different snapshots") |
||||||
|
} |
||||||
|
|
||||||
|
o.tfrs = append(o.tfrs, s) |
||||||
|
|
||||||
|
return o, nil |
||||||
|
} |
||||||
|
|
||||||
|
type OptimizeTFRDisjunctionUnadorned struct { |
||||||
|
snapshot *IndexSnapshot |
||||||
|
|
||||||
|
tfrs []*IndexSnapshotTermFieldReader |
||||||
|
} |
||||||
|
|
||||||
|
var OptimizeTFRDisjunctionUnadornedTerm = []byte("<disjunction:unadorned>") |
||||||
|
var OptimizeTFRDisjunctionUnadornedField = "*" |
||||||
|
|
||||||
|
// Finish of an unadorned disjunction optimization will compute a
|
||||||
|
// termFieldReader with an "actual" bitmap that represents the
|
||||||
|
// constituent bitmaps OR'ed together. This termFieldReader cannot
|
||||||
|
// provide any freq-norm or termVector associated information.
|
||||||
|
func (o *OptimizeTFRDisjunctionUnadorned) Finish() (rv index.Optimized, err error) { |
||||||
|
if len(o.tfrs) <= 1 { |
||||||
|
return nil, nil |
||||||
|
} |
||||||
|
|
||||||
|
for i := range o.snapshot.segment { |
||||||
|
var cMax uint64 |
||||||
|
|
||||||
|
for _, tfr := range o.tfrs { |
||||||
|
itr, ok := tfr.iterators[i].(*zap.PostingsIterator) |
||||||
|
if !ok { |
||||||
|
return nil, nil |
||||||
|
} |
||||||
|
|
||||||
|
if itr.ActualBM != nil { |
||||||
|
c := itr.ActualBM.GetCardinality() |
||||||
|
if cMax < c { |
||||||
|
cMax = c |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
// Heuristic to skip the optimization if all the constituent
|
||||||
|
// bitmaps are too small, where the processing & resource
|
||||||
|
// overhead to create the OR'ed bitmap outweighs the benefit.
|
||||||
|
if cMax < OptimizeDisjunctionUnadornedMinChildCardinality { |
||||||
|
return nil, nil |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
// We use an artificial term and field because the optimized
|
||||||
|
// termFieldReader can represent multiple terms and fields.
|
||||||
|
oTFR := &IndexSnapshotTermFieldReader{ |
||||||
|
term: OptimizeTFRDisjunctionUnadornedTerm, |
||||||
|
field: OptimizeTFRDisjunctionUnadornedField, |
||||||
|
snapshot: o.snapshot, |
||||||
|
iterators: make([]segment.PostingsIterator, len(o.snapshot.segment)), |
||||||
|
segmentOffset: 0, |
||||||
|
includeFreq: false, |
||||||
|
includeNorm: false, |
||||||
|
includeTermVectors: false, |
||||||
|
} |
||||||
|
|
||||||
|
var docNums []uint32 // Collected docNum's from 1-hit posting lists.
|
||||||
|
var actualBMs []*roaring.Bitmap // Collected from regular posting lists.
|
||||||
|
|
||||||
|
for i := range o.snapshot.segment { |
||||||
|
docNums = docNums[:0] |
||||||
|
actualBMs = actualBMs[:0] |
||||||
|
|
||||||
|
for _, tfr := range o.tfrs { |
||||||
|
itr, ok := tfr.iterators[i].(*zap.PostingsIterator) |
||||||
|
if !ok { |
||||||
|
return nil, nil |
||||||
|
} |
||||||
|
|
||||||
|
docNum, ok := itr.DocNum1Hit() |
||||||
|
if ok { |
||||||
|
docNums = append(docNums, uint32(docNum)) |
||||||
|
continue |
||||||
|
} |
||||||
|
|
||||||
|
if itr.ActualBM != nil { |
||||||
|
actualBMs = append(actualBMs, itr.ActualBM) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
var bm *roaring.Bitmap |
||||||
|
if len(actualBMs) > 2 { |
||||||
|
bm = roaring.HeapOr(actualBMs...) |
||||||
|
} else if len(actualBMs) == 2 { |
||||||
|
bm = roaring.Or(actualBMs[0], actualBMs[1]) |
||||||
|
} else if len(actualBMs) == 1 { |
||||||
|
bm = actualBMs[0].Clone() |
||||||
|
} |
||||||
|
|
||||||
|
if bm == nil { |
||||||
|
bm = roaring.New() |
||||||
|
} |
||||||
|
|
||||||
|
bm.AddMany(docNums) |
||||||
|
|
||||||
|
oTFR.iterators[i], err = zap.PostingsIteratorFromBitmap(bm, false, false) |
||||||
|
if err != nil { |
||||||
|
return nil, nil |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
return oTFR, nil |
||||||
|
} |
||||||
@ -1,110 +0,0 @@ |
|||||||
// Copyright (c) 2017 Couchbase, Inc.
|
|
||||||
//
|
|
||||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
||||||
// you may not use this file except in compliance with the License.
|
|
||||||
// You may obtain a copy of the License at
|
|
||||||
//
|
|
||||||
// http://www.apache.org/licenses/LICENSE-2.0
|
|
||||||
//
|
|
||||||
// Unless required by applicable law or agreed to in writing, software
|
|
||||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
||||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
||||||
// See the License for the specific language governing permissions and
|
|
||||||
// limitations under the License.
|
|
||||||
|
|
||||||
package scorch |
|
||||||
|
|
||||||
import ( |
|
||||||
"github.com/blevesearch/bleve/document" |
|
||||||
"github.com/blevesearch/bleve/index" |
|
||||||
) |
|
||||||
|
|
||||||
type Reader struct { |
|
||||||
root *IndexSnapshot // Owns 1 ref-count on the index snapshot.
|
|
||||||
} |
|
||||||
|
|
||||||
func (r *Reader) TermFieldReader(term []byte, field string, includeFreq, |
|
||||||
includeNorm, includeTermVectors bool) (index.TermFieldReader, error) { |
|
||||||
return r.root.TermFieldReader(term, field, includeFreq, includeNorm, includeTermVectors) |
|
||||||
} |
|
||||||
|
|
||||||
// DocIDReader returns an iterator over all doc ids
|
|
||||||
// The caller must close returned instance to release associated resources.
|
|
||||||
func (r *Reader) DocIDReaderAll() (index.DocIDReader, error) { |
|
||||||
return r.root.DocIDReaderAll() |
|
||||||
} |
|
||||||
|
|
||||||
func (r *Reader) DocIDReaderOnly(ids []string) (index.DocIDReader, error) { |
|
||||||
return r.root.DocIDReaderOnly(ids) |
|
||||||
} |
|
||||||
|
|
||||||
func (r *Reader) FieldDict(field string) (index.FieldDict, error) { |
|
||||||
return r.root.FieldDict(field) |
|
||||||
} |
|
||||||
|
|
||||||
// FieldDictRange is currently defined to include the start and end terms
|
|
||||||
func (r *Reader) FieldDictRange(field string, startTerm []byte, |
|
||||||
endTerm []byte) (index.FieldDict, error) { |
|
||||||
return r.root.FieldDictRange(field, startTerm, endTerm) |
|
||||||
} |
|
||||||
|
|
||||||
func (r *Reader) FieldDictPrefix(field string, |
|
||||||
termPrefix []byte) (index.FieldDict, error) { |
|
||||||
return r.root.FieldDictPrefix(field, termPrefix) |
|
||||||
} |
|
||||||
|
|
||||||
func (r *Reader) Document(id string) (*document.Document, error) { |
|
||||||
return r.root.Document(id) |
|
||||||
} |
|
||||||
func (r *Reader) DocumentVisitFieldTerms(id index.IndexInternalID, fields []string, |
|
||||||
visitor index.DocumentFieldTermVisitor) error { |
|
||||||
return r.root.DocumentVisitFieldTerms(id, fields, visitor) |
|
||||||
} |
|
||||||
|
|
||||||
func (r *Reader) Fields() ([]string, error) { |
|
||||||
return r.root.Fields() |
|
||||||
} |
|
||||||
|
|
||||||
func (r *Reader) GetInternal(key []byte) ([]byte, error) { |
|
||||||
return r.root.GetInternal(key) |
|
||||||
} |
|
||||||
|
|
||||||
func (r *Reader) DocCount() (uint64, error) { |
|
||||||
return r.root.DocCount() |
|
||||||
} |
|
||||||
|
|
||||||
func (r *Reader) ExternalID(id index.IndexInternalID) (string, error) { |
|
||||||
return r.root.ExternalID(id) |
|
||||||
} |
|
||||||
|
|
||||||
func (r *Reader) InternalID(id string) (index.IndexInternalID, error) { |
|
||||||
return r.root.InternalID(id) |
|
||||||
} |
|
||||||
|
|
||||||
func (r *Reader) DumpAll() chan interface{} { |
|
||||||
rv := make(chan interface{}) |
|
||||||
go func() { |
|
||||||
close(rv) |
|
||||||
}() |
|
||||||
return rv |
|
||||||
} |
|
||||||
|
|
||||||
func (r *Reader) DumpDoc(id string) chan interface{} { |
|
||||||
rv := make(chan interface{}) |
|
||||||
go func() { |
|
||||||
close(rv) |
|
||||||
}() |
|
||||||
return rv |
|
||||||
} |
|
||||||
|
|
||||||
func (r *Reader) DumpFields() chan interface{} { |
|
||||||
rv := make(chan interface{}) |
|
||||||
go func() { |
|
||||||
close(rv) |
|
||||||
}() |
|
||||||
return rv |
|
||||||
} |
|
||||||
|
|
||||||
func (r *Reader) Close() error { |
|
||||||
return r.root.DecRef() |
|
||||||
} |
|
||||||
@ -1,321 +0,0 @@ |
|||||||
// Copyright (c) 2017 Couchbase, Inc.
|
|
||||||
//
|
|
||||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
||||||
// you may not use this file except in compliance with the License.
|
|
||||||
// You may obtain a copy of the License at
|
|
||||||
//
|
|
||||||
// http://www.apache.org/licenses/LICENSE-2.0
|
|
||||||
//
|
|
||||||
// Unless required by applicable law or agreed to in writing, software
|
|
||||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
||||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
||||||
// See the License for the specific language governing permissions and
|
|
||||||
// limitations under the License.
|
|
||||||
|
|
||||||
package mem |
|
||||||
|
|
||||||
import ( |
|
||||||
"math" |
|
||||||
"sort" |
|
||||||
|
|
||||||
"github.com/RoaringBitmap/roaring" |
|
||||||
"github.com/blevesearch/bleve/analysis" |
|
||||||
"github.com/blevesearch/bleve/document" |
|
||||||
"github.com/blevesearch/bleve/index" |
|
||||||
) |
|
||||||
|
|
||||||
// NewFromAnalyzedDocs places the analyzed document mutations into a new segment
|
|
||||||
func NewFromAnalyzedDocs(results []*index.AnalysisResult) *Segment { |
|
||||||
s := New() |
|
||||||
|
|
||||||
// ensure that _id field get fieldID 0
|
|
||||||
s.getOrDefineField("_id") |
|
||||||
|
|
||||||
// fill Dicts/DictKeys and preallocate memory
|
|
||||||
s.initializeDict(results) |
|
||||||
|
|
||||||
// walk each doc
|
|
||||||
for _, result := range results { |
|
||||||
s.processDocument(result) |
|
||||||
} |
|
||||||
|
|
||||||
// go back and sort the dictKeys
|
|
||||||
for _, dict := range s.DictKeys { |
|
||||||
sort.Strings(dict) |
|
||||||
} |
|
||||||
|
|
||||||
// compute memory usage of segment
|
|
||||||
s.updateSizeInBytes() |
|
||||||
|
|
||||||
// professional debugging
|
|
||||||
//
|
|
||||||
// log.Printf("fields: %v\n", s.FieldsMap)
|
|
||||||
// log.Printf("fieldsInv: %v\n", s.FieldsInv)
|
|
||||||
// log.Printf("fieldsLoc: %v\n", s.FieldsLoc)
|
|
||||||
// log.Printf("dicts: %v\n", s.Dicts)
|
|
||||||
// log.Printf("dict keys: %v\n", s.DictKeys)
|
|
||||||
// for i, posting := range s.Postings {
|
|
||||||
// log.Printf("posting %d: %v\n", i, posting)
|
|
||||||
// }
|
|
||||||
// for i, freq := range s.Freqs {
|
|
||||||
// log.Printf("freq %d: %v\n", i, freq)
|
|
||||||
// }
|
|
||||||
// for i, norm := range s.Norms {
|
|
||||||
// log.Printf("norm %d: %v\n", i, norm)
|
|
||||||
// }
|
|
||||||
// for i, field := range s.Locfields {
|
|
||||||
// log.Printf("field %d: %v\n", i, field)
|
|
||||||
// }
|
|
||||||
// for i, start := range s.Locstarts {
|
|
||||||
// log.Printf("start %d: %v\n", i, start)
|
|
||||||
// }
|
|
||||||
// for i, end := range s.Locends {
|
|
||||||
// log.Printf("end %d: %v\n", i, end)
|
|
||||||
// }
|
|
||||||
// for i, pos := range s.Locpos {
|
|
||||||
// log.Printf("pos %d: %v\n", i, pos)
|
|
||||||
// }
|
|
||||||
// for i, apos := range s.Locarraypos {
|
|
||||||
// log.Printf("apos %d: %v\n", i, apos)
|
|
||||||
// }
|
|
||||||
// log.Printf("stored: %v\n", s.Stored)
|
|
||||||
// log.Printf("stored types: %v\n", s.StoredTypes)
|
|
||||||
// log.Printf("stored pos: %v\n", s.StoredPos)
|
|
||||||
|
|
||||||
return s |
|
||||||
} |
|
||||||
|
|
||||||
// fill Dicts/DictKeys and preallocate memory for postings
|
|
||||||
func (s *Segment) initializeDict(results []*index.AnalysisResult) { |
|
||||||
var numPostingsLists int |
|
||||||
|
|
||||||
numTermsPerPostingsList := make([]int, 0, 64) // Keyed by postings list id.
|
|
||||||
numLocsPerPostingsList := make([]int, 0, 64) // Keyed by postings list id.
|
|
||||||
|
|
||||||
var numTokenFrequencies int |
|
||||||
var totLocs int |
|
||||||
|
|
||||||
// initial scan for all fieldID's to sort them
|
|
||||||
for _, result := range results { |
|
||||||
for _, field := range result.Document.CompositeFields { |
|
||||||
s.getOrDefineField(field.Name()) |
|
||||||
} |
|
||||||
for _, field := range result.Document.Fields { |
|
||||||
s.getOrDefineField(field.Name()) |
|
||||||
} |
|
||||||
} |
|
||||||
sort.Strings(s.FieldsInv[1:]) // keep _id as first field
|
|
||||||
s.FieldsMap = make(map[string]uint16, len(s.FieldsInv)) |
|
||||||
for fieldID, fieldName := range s.FieldsInv { |
|
||||||
s.FieldsMap[fieldName] = uint16(fieldID + 1) |
|
||||||
} |
|
||||||
|
|
||||||
processField := func(fieldID uint16, tfs analysis.TokenFrequencies) { |
|
||||||
for term, tf := range tfs { |
|
||||||
pidPlus1, exists := s.Dicts[fieldID][term] |
|
||||||
if !exists { |
|
||||||
numPostingsLists++ |
|
||||||
pidPlus1 = uint64(numPostingsLists) |
|
||||||
s.Dicts[fieldID][term] = pidPlus1 |
|
||||||
s.DictKeys[fieldID] = append(s.DictKeys[fieldID], term) |
|
||||||
numTermsPerPostingsList = append(numTermsPerPostingsList, 0) |
|
||||||
numLocsPerPostingsList = append(numLocsPerPostingsList, 0) |
|
||||||
} |
|
||||||
pid := pidPlus1 - 1 |
|
||||||
numTermsPerPostingsList[pid] += 1 |
|
||||||
numLocsPerPostingsList[pid] += len(tf.Locations) |
|
||||||
totLocs += len(tf.Locations) |
|
||||||
} |
|
||||||
numTokenFrequencies += len(tfs) |
|
||||||
} |
|
||||||
|
|
||||||
for _, result := range results { |
|
||||||
// walk each composite field
|
|
||||||
for _, field := range result.Document.CompositeFields { |
|
||||||
fieldID := uint16(s.getOrDefineField(field.Name())) |
|
||||||
_, tf := field.Analyze() |
|
||||||
processField(fieldID, tf) |
|
||||||
} |
|
||||||
|
|
||||||
// walk each field
|
|
||||||
for i, field := range result.Document.Fields { |
|
||||||
fieldID := uint16(s.getOrDefineField(field.Name())) |
|
||||||
tf := result.Analyzed[i] |
|
||||||
processField(fieldID, tf) |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
s.Postings = make([]*roaring.Bitmap, numPostingsLists) |
|
||||||
for i := 0; i < numPostingsLists; i++ { |
|
||||||
s.Postings[i] = roaring.New() |
|
||||||
} |
|
||||||
s.PostingsLocs = make([]*roaring.Bitmap, numPostingsLists) |
|
||||||
for i := 0; i < numPostingsLists; i++ { |
|
||||||
s.PostingsLocs[i] = roaring.New() |
|
||||||
} |
|
||||||
|
|
||||||
// Preallocate big, contiguous backing arrays.
|
|
||||||
auint64Backing := make([][]uint64, numPostingsLists*4+totLocs) // For Freqs, Locstarts, Locends, Locpos, sub-Locarraypos.
|
|
||||||
uint64Backing := make([]uint64, numTokenFrequencies+totLocs*3) // For sub-Freqs, sub-Locstarts, sub-Locends, sub-Locpos.
|
|
||||||
float32Backing := make([]float32, numTokenFrequencies) // For sub-Norms.
|
|
||||||
uint16Backing := make([]uint16, totLocs) // For sub-Locfields.
|
|
||||||
|
|
||||||
// Point top-level slices to the backing arrays.
|
|
||||||
s.Freqs = auint64Backing[0:numPostingsLists] |
|
||||||
auint64Backing = auint64Backing[numPostingsLists:] |
|
||||||
|
|
||||||
s.Norms = make([][]float32, numPostingsLists) |
|
||||||
|
|
||||||
s.Locfields = make([][]uint16, numPostingsLists) |
|
||||||
|
|
||||||
s.Locstarts = auint64Backing[0:numPostingsLists] |
|
||||||
auint64Backing = auint64Backing[numPostingsLists:] |
|
||||||
|
|
||||||
s.Locends = auint64Backing[0:numPostingsLists] |
|
||||||
auint64Backing = auint64Backing[numPostingsLists:] |
|
||||||
|
|
||||||
s.Locpos = auint64Backing[0:numPostingsLists] |
|
||||||
auint64Backing = auint64Backing[numPostingsLists:] |
|
||||||
|
|
||||||
s.Locarraypos = make([][][]uint64, numPostingsLists) |
|
||||||
|
|
||||||
// Point sub-slices to the backing arrays.
|
|
||||||
for pid, numTerms := range numTermsPerPostingsList { |
|
||||||
s.Freqs[pid] = uint64Backing[0:0] |
|
||||||
uint64Backing = uint64Backing[numTerms:] |
|
||||||
|
|
||||||
s.Norms[pid] = float32Backing[0:0] |
|
||||||
float32Backing = float32Backing[numTerms:] |
|
||||||
} |
|
||||||
|
|
||||||
for pid, numLocs := range numLocsPerPostingsList { |
|
||||||
s.Locfields[pid] = uint16Backing[0:0] |
|
||||||
uint16Backing = uint16Backing[numLocs:] |
|
||||||
|
|
||||||
s.Locstarts[pid] = uint64Backing[0:0] |
|
||||||
uint64Backing = uint64Backing[numLocs:] |
|
||||||
|
|
||||||
s.Locends[pid] = uint64Backing[0:0] |
|
||||||
uint64Backing = uint64Backing[numLocs:] |
|
||||||
|
|
||||||
s.Locpos[pid] = uint64Backing[0:0] |
|
||||||
uint64Backing = uint64Backing[numLocs:] |
|
||||||
|
|
||||||
s.Locarraypos[pid] = auint64Backing[0:0] |
|
||||||
auint64Backing = auint64Backing[numLocs:] |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
func (s *Segment) processDocument(result *index.AnalysisResult) { |
|
||||||
// used to collate information across fields
|
|
||||||
docMap := make(map[uint16]analysis.TokenFrequencies, len(s.FieldsMap)) |
|
||||||
fieldLens := make(map[uint16]int, len(s.FieldsMap)) |
|
||||||
|
|
||||||
docNum := uint64(s.addDocument()) |
|
||||||
|
|
||||||
processField := func(field uint16, name string, l int, tf analysis.TokenFrequencies) { |
|
||||||
fieldLens[field] += l |
|
||||||
if existingFreqs, ok := docMap[field]; ok { |
|
||||||
existingFreqs.MergeAll(name, tf) |
|
||||||
} else { |
|
||||||
docMap[field] = tf |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
storeField := func(docNum uint64, field uint16, typ byte, val []byte, pos []uint64) { |
|
||||||
s.Stored[docNum][field] = append(s.Stored[docNum][field], val) |
|
||||||
s.StoredTypes[docNum][field] = append(s.StoredTypes[docNum][field], typ) |
|
||||||
s.StoredPos[docNum][field] = append(s.StoredPos[docNum][field], pos) |
|
||||||
} |
|
||||||
|
|
||||||
// walk each composite field
|
|
||||||
for _, field := range result.Document.CompositeFields { |
|
||||||
fieldID := uint16(s.getOrDefineField(field.Name())) |
|
||||||
l, tf := field.Analyze() |
|
||||||
processField(fieldID, field.Name(), l, tf) |
|
||||||
} |
|
||||||
|
|
||||||
// walk each field
|
|
||||||
for i, field := range result.Document.Fields { |
|
||||||
fieldID := uint16(s.getOrDefineField(field.Name())) |
|
||||||
l := result.Length[i] |
|
||||||
tf := result.Analyzed[i] |
|
||||||
processField(fieldID, field.Name(), l, tf) |
|
||||||
if field.Options().IsStored() { |
|
||||||
storeField(docNum, fieldID, encodeFieldType(field), field.Value(), field.ArrayPositions()) |
|
||||||
} |
|
||||||
|
|
||||||
if field.Options().IncludeDocValues() { |
|
||||||
s.DocValueFields[fieldID] = true |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
// now that its been rolled up into docMap, walk that
|
|
||||||
for fieldID, tokenFrequencies := range docMap { |
|
||||||
for term, tokenFreq := range tokenFrequencies { |
|
||||||
pid := s.Dicts[fieldID][term] - 1 |
|
||||||
bs := s.Postings[pid] |
|
||||||
bs.AddInt(int(docNum)) |
|
||||||
s.Freqs[pid] = append(s.Freqs[pid], uint64(tokenFreq.Frequency())) |
|
||||||
s.Norms[pid] = append(s.Norms[pid], float32(1.0/math.Sqrt(float64(fieldLens[fieldID])))) |
|
||||||
locationBS := s.PostingsLocs[pid] |
|
||||||
if len(tokenFreq.Locations) > 0 { |
|
||||||
locationBS.AddInt(int(docNum)) |
|
||||||
for _, loc := range tokenFreq.Locations { |
|
||||||
var locf = fieldID |
|
||||||
if loc.Field != "" { |
|
||||||
locf = uint16(s.getOrDefineField(loc.Field)) |
|
||||||
} |
|
||||||
s.Locfields[pid] = append(s.Locfields[pid], locf) |
|
||||||
s.Locstarts[pid] = append(s.Locstarts[pid], uint64(loc.Start)) |
|
||||||
s.Locends[pid] = append(s.Locends[pid], uint64(loc.End)) |
|
||||||
s.Locpos[pid] = append(s.Locpos[pid], uint64(loc.Position)) |
|
||||||
if len(loc.ArrayPositions) > 0 { |
|
||||||
s.Locarraypos[pid] = append(s.Locarraypos[pid], loc.ArrayPositions) |
|
||||||
} else { |
|
||||||
s.Locarraypos[pid] = append(s.Locarraypos[pid], nil) |
|
||||||
} |
|
||||||
} |
|
||||||
} |
|
||||||
} |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
func (s *Segment) getOrDefineField(name string) int { |
|
||||||
fieldIDPlus1, ok := s.FieldsMap[name] |
|
||||||
if !ok { |
|
||||||
fieldIDPlus1 = uint16(len(s.FieldsInv) + 1) |
|
||||||
s.FieldsMap[name] = fieldIDPlus1 |
|
||||||
s.FieldsInv = append(s.FieldsInv, name) |
|
||||||
s.Dicts = append(s.Dicts, make(map[string]uint64)) |
|
||||||
s.DictKeys = append(s.DictKeys, make([]string, 0)) |
|
||||||
} |
|
||||||
return int(fieldIDPlus1 - 1) |
|
||||||
} |
|
||||||
|
|
||||||
func (s *Segment) addDocument() int { |
|
||||||
docNum := len(s.Stored) |
|
||||||
s.Stored = append(s.Stored, map[uint16][][]byte{}) |
|
||||||
s.StoredTypes = append(s.StoredTypes, map[uint16][]byte{}) |
|
||||||
s.StoredPos = append(s.StoredPos, map[uint16][][]uint64{}) |
|
||||||
return docNum |
|
||||||
} |
|
||||||
|
|
||||||
func encodeFieldType(f document.Field) byte { |
|
||||||
fieldType := byte('x') |
|
||||||
switch f.(type) { |
|
||||||
case *document.TextField: |
|
||||||
fieldType = 't' |
|
||||||
case *document.NumericField: |
|
||||||
fieldType = 'n' |
|
||||||
case *document.DateTimeField: |
|
||||||
fieldType = 'd' |
|
||||||
case *document.BooleanField: |
|
||||||
fieldType = 'b' |
|
||||||
case *document.GeoPointField: |
|
||||||
fieldType = 'g' |
|
||||||
case *document.CompositeField: |
|
||||||
fieldType = 'c' |
|
||||||
} |
|
||||||
return fieldType |
|
||||||
} |
|
||||||
@ -1,103 +0,0 @@ |
|||||||
// Copyright (c) 2017 Couchbase, Inc.
|
|
||||||
//
|
|
||||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
||||||
// you may not use this file except in compliance with the License.
|
|
||||||
// You may obtain a copy of the License at
|
|
||||||
//
|
|
||||||
// http://www.apache.org/licenses/LICENSE-2.0
|
|
||||||
//
|
|
||||||
// Unless required by applicable law or agreed to in writing, software
|
|
||||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
||||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
||||||
// See the License for the specific language governing permissions and
|
|
||||||
// limitations under the License.
|
|
||||||
|
|
||||||
package mem |
|
||||||
|
|
||||||
import ( |
|
||||||
"sort" |
|
||||||
"strings" |
|
||||||
|
|
||||||
"github.com/RoaringBitmap/roaring" |
|
||||||
"github.com/blevesearch/bleve/index" |
|
||||||
"github.com/blevesearch/bleve/index/scorch/segment" |
|
||||||
) |
|
||||||
|
|
||||||
// Dictionary is the in-memory representation of the term dictionary
|
|
||||||
type Dictionary struct { |
|
||||||
segment *Segment |
|
||||||
field string |
|
||||||
fieldID uint16 |
|
||||||
} |
|
||||||
|
|
||||||
// PostingsList returns the postings list for the specified term
|
|
||||||
func (d *Dictionary) PostingsList(term string, |
|
||||||
except *roaring.Bitmap) (segment.PostingsList, error) { |
|
||||||
return &PostingsList{ |
|
||||||
dictionary: d, |
|
||||||
term: term, |
|
||||||
postingsID: d.segment.Dicts[d.fieldID][term], |
|
||||||
except: except, |
|
||||||
}, nil |
|
||||||
} |
|
||||||
|
|
||||||
// Iterator returns an iterator for this dictionary
|
|
||||||
func (d *Dictionary) Iterator() segment.DictionaryIterator { |
|
||||||
return &DictionaryIterator{ |
|
||||||
d: d, |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
// PrefixIterator returns an iterator which only visits terms having the
|
|
||||||
// the specified prefix
|
|
||||||
func (d *Dictionary) PrefixIterator(prefix string) segment.DictionaryIterator { |
|
||||||
offset := sort.SearchStrings(d.segment.DictKeys[d.fieldID], prefix) |
|
||||||
return &DictionaryIterator{ |
|
||||||
d: d, |
|
||||||
prefix: prefix, |
|
||||||
offset: offset, |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
// RangeIterator returns an iterator which only visits terms between the
|
|
||||||
// start and end terms. NOTE: bleve.index API specifies the end is inclusive.
|
|
||||||
func (d *Dictionary) RangeIterator(start, end string) segment.DictionaryIterator { |
|
||||||
offset := sort.SearchStrings(d.segment.DictKeys[d.fieldID], start) |
|
||||||
return &DictionaryIterator{ |
|
||||||
d: d, |
|
||||||
offset: offset, |
|
||||||
end: end, |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
// DictionaryIterator is an iterator for term dictionary
|
|
||||||
type DictionaryIterator struct { |
|
||||||
d *Dictionary |
|
||||||
prefix string |
|
||||||
end string |
|
||||||
offset int |
|
||||||
|
|
||||||
dictEntry index.DictEntry // reused across Next()'s
|
|
||||||
} |
|
||||||
|
|
||||||
// Next returns the next entry in the dictionary
|
|
||||||
func (d *DictionaryIterator) Next() (*index.DictEntry, error) { |
|
||||||
if d.offset > len(d.d.segment.DictKeys[d.d.fieldID])-1 { |
|
||||||
return nil, nil |
|
||||||
} |
|
||||||
next := d.d.segment.DictKeys[d.d.fieldID][d.offset] |
|
||||||
// check prefix
|
|
||||||
if d.prefix != "" && !strings.HasPrefix(next, d.prefix) { |
|
||||||
return nil, nil |
|
||||||
} |
|
||||||
// check end (bleve.index API demands inclusive end)
|
|
||||||
if d.end != "" && next > d.end { |
|
||||||
return nil, nil |
|
||||||
} |
|
||||||
|
|
||||||
d.offset++ |
|
||||||
postingID := d.d.segment.Dicts[d.d.fieldID][next] |
|
||||||
d.dictEntry.Term = next |
|
||||||
d.dictEntry.Count = d.d.segment.Postings[postingID-1].GetCardinality() |
|
||||||
return &d.dictEntry, nil |
|
||||||
} |
|
||||||
@ -1,178 +0,0 @@ |
|||||||
// Copyright (c) 2017 Couchbase, Inc.
|
|
||||||
//
|
|
||||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
||||||
// you may not use this file except in compliance with the License.
|
|
||||||
// You may obtain a copy of the License at
|
|
||||||
//
|
|
||||||
// http://www.apache.org/licenses/LICENSE-2.0
|
|
||||||
//
|
|
||||||
// Unless required by applicable law or agreed to in writing, software
|
|
||||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
||||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
||||||
// See the License for the specific language governing permissions and
|
|
||||||
// limitations under the License.
|
|
||||||
|
|
||||||
package mem |
|
||||||
|
|
||||||
import ( |
|
||||||
"github.com/RoaringBitmap/roaring" |
|
||||||
"github.com/blevesearch/bleve/index/scorch/segment" |
|
||||||
) |
|
||||||
|
|
||||||
// PostingsList is an in-memory represenation of a postings list
|
|
||||||
type PostingsList struct { |
|
||||||
dictionary *Dictionary |
|
||||||
term string |
|
||||||
postingsID uint64 |
|
||||||
except *roaring.Bitmap |
|
||||||
} |
|
||||||
|
|
||||||
// Count returns the number of items on this postings list
|
|
||||||
func (p *PostingsList) Count() uint64 { |
|
||||||
var rv uint64 |
|
||||||
if p.postingsID > 0 { |
|
||||||
rv = p.dictionary.segment.Postings[p.postingsID-1].GetCardinality() |
|
||||||
if p.except != nil { |
|
||||||
except := p.except.GetCardinality() |
|
||||||
if except > rv { |
|
||||||
// avoid underflow
|
|
||||||
except = rv |
|
||||||
} |
|
||||||
rv -= except |
|
||||||
} |
|
||||||
} |
|
||||||
return rv |
|
||||||
} |
|
||||||
|
|
||||||
// Iterator returns an iterator for this postings list
|
|
||||||
func (p *PostingsList) Iterator() segment.PostingsIterator { |
|
||||||
rv := &PostingsIterator{ |
|
||||||
postings: p, |
|
||||||
} |
|
||||||
if p.postingsID > 0 { |
|
||||||
allbits := p.dictionary.segment.Postings[p.postingsID-1] |
|
||||||
rv.locations = p.dictionary.segment.PostingsLocs[p.postingsID-1] |
|
||||||
rv.all = allbits.Iterator() |
|
||||||
if p.except != nil { |
|
||||||
allExcept := allbits.Clone() |
|
||||||
allExcept.AndNot(p.except) |
|
||||||
rv.actual = allExcept.Iterator() |
|
||||||
} else { |
|
||||||
rv.actual = allbits.Iterator() |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
return rv |
|
||||||
} |
|
||||||
|
|
||||||
// PostingsIterator provides a way to iterate through the postings list
|
|
||||||
type PostingsIterator struct { |
|
||||||
postings *PostingsList |
|
||||||
all roaring.IntIterable |
|
||||||
locations *roaring.Bitmap |
|
||||||
offset int |
|
||||||
locoffset int |
|
||||||
actual roaring.IntIterable |
|
||||||
} |
|
||||||
|
|
||||||
// Next returns the next posting on the postings list, or nil at the end
|
|
||||||
func (i *PostingsIterator) Next() (segment.Posting, error) { |
|
||||||
if i.actual == nil || !i.actual.HasNext() { |
|
||||||
return nil, nil |
|
||||||
} |
|
||||||
n := i.actual.Next() |
|
||||||
allN := i.all.Next() |
|
||||||
|
|
||||||
// n is the next actual hit (excluding some postings)
|
|
||||||
// allN is the next hit in the full postings
|
|
||||||
// if they don't match, adjust offsets to factor in item we're skipping over
|
|
||||||
// incr the all iterator, and check again
|
|
||||||
for allN != n { |
|
||||||
i.locoffset += int(i.postings.dictionary.segment.Freqs[i.postings.postingsID-1][i.offset]) |
|
||||||
i.offset++ |
|
||||||
allN = i.all.Next() |
|
||||||
} |
|
||||||
rv := &Posting{ |
|
||||||
iterator: i, |
|
||||||
docNum: uint64(n), |
|
||||||
offset: i.offset, |
|
||||||
locoffset: i.locoffset, |
|
||||||
hasLoc: i.locations.Contains(n), |
|
||||||
} |
|
||||||
|
|
||||||
i.locoffset += int(i.postings.dictionary.segment.Freqs[i.postings.postingsID-1][i.offset]) |
|
||||||
i.offset++ |
|
||||||
return rv, nil |
|
||||||
} |
|
||||||
|
|
||||||
// Posting is a single entry in a postings list
|
|
||||||
type Posting struct { |
|
||||||
iterator *PostingsIterator |
|
||||||
docNum uint64 |
|
||||||
offset int |
|
||||||
locoffset int |
|
||||||
hasLoc bool |
|
||||||
} |
|
||||||
|
|
||||||
// Number returns the document number of this posting in this segment
|
|
||||||
func (p *Posting) Number() uint64 { |
|
||||||
return p.docNum |
|
||||||
} |
|
||||||
|
|
||||||
// Frequency returns the frequence of occurance of this term in this doc/field
|
|
||||||
func (p *Posting) Frequency() uint64 { |
|
||||||
return p.iterator.postings.dictionary.segment.Freqs[p.iterator.postings.postingsID-1][p.offset] |
|
||||||
} |
|
||||||
|
|
||||||
// Norm returns the normalization factor for this posting
|
|
||||||
func (p *Posting) Norm() float64 { |
|
||||||
return float64(p.iterator.postings.dictionary.segment.Norms[p.iterator.postings.postingsID-1][p.offset]) |
|
||||||
} |
|
||||||
|
|
||||||
// Locations returns the location information for each occurance
|
|
||||||
func (p *Posting) Locations() []segment.Location { |
|
||||||
if !p.hasLoc { |
|
||||||
return nil |
|
||||||
} |
|
||||||
freq := int(p.Frequency()) |
|
||||||
rv := make([]segment.Location, freq) |
|
||||||
for i := 0; i < freq; i++ { |
|
||||||
rv[i] = &Location{ |
|
||||||
p: p, |
|
||||||
offset: p.locoffset + i, |
|
||||||
} |
|
||||||
} |
|
||||||
return rv |
|
||||||
} |
|
||||||
|
|
||||||
// Location represents the location of a single occurance
|
|
||||||
type Location struct { |
|
||||||
p *Posting |
|
||||||
offset int |
|
||||||
} |
|
||||||
|
|
||||||
// Field returns the name of the field (useful in composite fields to know
|
|
||||||
// which original field the value came from)
|
|
||||||
func (l *Location) Field() string { |
|
||||||
return l.p.iterator.postings.dictionary.segment.FieldsInv[l.p.iterator.postings.dictionary.segment.Locfields[l.p.iterator.postings.postingsID-1][l.offset]] |
|
||||||
} |
|
||||||
|
|
||||||
// Start returns the start byte offset of this occurance
|
|
||||||
func (l *Location) Start() uint64 { |
|
||||||
return l.p.iterator.postings.dictionary.segment.Locstarts[l.p.iterator.postings.postingsID-1][l.offset] |
|
||||||
} |
|
||||||
|
|
||||||
// End returns the end byte offset of this occurance
|
|
||||||
func (l *Location) End() uint64 { |
|
||||||
return l.p.iterator.postings.dictionary.segment.Locends[l.p.iterator.postings.postingsID-1][l.offset] |
|
||||||
} |
|
||||||
|
|
||||||
// Pos returns the 1-based phrase position of this occurance
|
|
||||||
func (l *Location) Pos() uint64 { |
|
||||||
return l.p.iterator.postings.dictionary.segment.Locpos[l.p.iterator.postings.postingsID-1][l.offset] |
|
||||||
} |
|
||||||
|
|
||||||
// ArrayPositions returns the array position vector associated with this occurance
|
|
||||||
func (l *Location) ArrayPositions() []uint64 { |
|
||||||
return l.p.iterator.postings.dictionary.segment.Locarraypos[l.p.iterator.postings.postingsID-1][l.offset] |
|
||||||
} |
|
||||||
@ -1,289 +0,0 @@ |
|||||||
// Copyright (c) 2017 Couchbase, Inc.
|
|
||||||
//
|
|
||||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
||||||
// you may not use this file except in compliance with the License.
|
|
||||||
// You may obtain a copy of the License at
|
|
||||||
//
|
|
||||||
// http://www.apache.org/licenses/LICENSE-2.0
|
|
||||||
//
|
|
||||||
// Unless required by applicable law or agreed to in writing, software
|
|
||||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
||||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
||||||
// See the License for the specific language governing permissions and
|
|
||||||
// limitations under the License.
|
|
||||||
|
|
||||||
package mem |
|
||||||
|
|
||||||
import ( |
|
||||||
"fmt" |
|
||||||
|
|
||||||
"github.com/RoaringBitmap/roaring" |
|
||||||
"github.com/blevesearch/bleve/index/scorch/segment" |
|
||||||
) |
|
||||||
|
|
||||||
// _id field is always guaranteed to have fieldID of 0
|
|
||||||
const idFieldID uint16 = 0 |
|
||||||
|
|
||||||
// KNOWN ISSUES
|
|
||||||
// - LIMITATION - we decided whether or not to store term vectors for a field
|
|
||||||
// at the segment level, based on the first definition of a
|
|
||||||
// field we see. in normal bleve usage this is fine, all
|
|
||||||
// instances of a field definition will be the same. however,
|
|
||||||
// advanced users may violate this and provide unique field
|
|
||||||
// definitions with each document. this segment does not
|
|
||||||
// support this usage.
|
|
||||||
|
|
||||||
// TODO
|
|
||||||
// - need better testing of multiple docs, iterating freqs, locations and
|
|
||||||
// and verifying the correct results are returned
|
|
||||||
|
|
||||||
// Segment is an in memory implementation of scorch.Segment
|
|
||||||
type Segment struct { |
|
||||||
|
|
||||||
// FieldsMap adds 1 to field id to avoid zero value issues
|
|
||||||
// name -> field id + 1
|
|
||||||
FieldsMap map[string]uint16 |
|
||||||
|
|
||||||
// FieldsInv is the inverse of FieldsMap
|
|
||||||
// field id -> name
|
|
||||||
FieldsInv []string |
|
||||||
|
|
||||||
// Term dictionaries for each field
|
|
||||||
// field id -> term -> postings list id + 1
|
|
||||||
Dicts []map[string]uint64 |
|
||||||
|
|
||||||
// Terms for each field, where terms are sorted ascending
|
|
||||||
// field id -> []term
|
|
||||||
DictKeys [][]string |
|
||||||
|
|
||||||
// Postings list
|
|
||||||
// postings list id -> bitmap by docNum
|
|
||||||
Postings []*roaring.Bitmap |
|
||||||
|
|
||||||
// Postings list has locations
|
|
||||||
PostingsLocs []*roaring.Bitmap |
|
||||||
|
|
||||||
// Term frequencies
|
|
||||||
// postings list id -> Freqs (one for each hit in bitmap)
|
|
||||||
Freqs [][]uint64 |
|
||||||
|
|
||||||
// Field norms
|
|
||||||
// postings list id -> Norms (one for each hit in bitmap)
|
|
||||||
Norms [][]float32 |
|
||||||
|
|
||||||
// Field/start/end/pos/locarraypos
|
|
||||||
// postings list id -> start/end/pos/locarraypos (one for each freq)
|
|
||||||
Locfields [][]uint16 |
|
||||||
Locstarts [][]uint64 |
|
||||||
Locends [][]uint64 |
|
||||||
Locpos [][]uint64 |
|
||||||
Locarraypos [][][]uint64 |
|
||||||
|
|
||||||
// Stored field values
|
|
||||||
// docNum -> field id -> slice of values (each value []byte)
|
|
||||||
Stored []map[uint16][][]byte |
|
||||||
|
|
||||||
// Stored field types
|
|
||||||
// docNum -> field id -> slice of types (each type byte)
|
|
||||||
StoredTypes []map[uint16][]byte |
|
||||||
|
|
||||||
// Stored field array positions
|
|
||||||
// docNum -> field id -> slice of array positions (each is []uint64)
|
|
||||||
StoredPos []map[uint16][][]uint64 |
|
||||||
|
|
||||||
// For storing the docValue persisted fields
|
|
||||||
DocValueFields map[uint16]bool |
|
||||||
|
|
||||||
// Footprint of the segment, updated when analyzed document mutations
|
|
||||||
// are added into the segment
|
|
||||||
sizeInBytes uint64 |
|
||||||
} |
|
||||||
|
|
||||||
// New builds a new empty Segment
|
|
||||||
func New() *Segment { |
|
||||||
return &Segment{ |
|
||||||
FieldsMap: map[string]uint16{}, |
|
||||||
DocValueFields: map[uint16]bool{}, |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
func (s *Segment) updateSizeInBytes() { |
|
||||||
var sizeInBytes uint64 |
|
||||||
|
|
||||||
// FieldsMap, FieldsInv
|
|
||||||
for k, _ := range s.FieldsMap { |
|
||||||
sizeInBytes += uint64((len(k)+int(segment.SizeOfString))*2 + |
|
||||||
2 /* size of uint16 */) |
|
||||||
} |
|
||||||
// overhead from the data structures
|
|
||||||
sizeInBytes += (segment.SizeOfMap + segment.SizeOfSlice) |
|
||||||
|
|
||||||
// Dicts, DictKeys
|
|
||||||
for _, entry := range s.Dicts { |
|
||||||
for k, _ := range entry { |
|
||||||
sizeInBytes += uint64((len(k)+int(segment.SizeOfString))*2 + |
|
||||||
8 /* size of uint64 */) |
|
||||||
} |
|
||||||
// overhead from the data structures
|
|
||||||
sizeInBytes += (segment.SizeOfMap + segment.SizeOfSlice) |
|
||||||
} |
|
||||||
sizeInBytes += (segment.SizeOfSlice * 2) |
|
||||||
|
|
||||||
// Postings, PostingsLocs
|
|
||||||
for i := 0; i < len(s.Postings); i++ { |
|
||||||
sizeInBytes += (s.Postings[i].GetSizeInBytes() + segment.SizeOfPointer) + |
|
||||||
(s.PostingsLocs[i].GetSizeInBytes() + segment.SizeOfPointer) |
|
||||||
} |
|
||||||
sizeInBytes += (segment.SizeOfSlice * 2) |
|
||||||
|
|
||||||
// Freqs, Norms
|
|
||||||
for i := 0; i < len(s.Freqs); i++ { |
|
||||||
sizeInBytes += uint64(len(s.Freqs[i])*8 /* size of uint64 */ + |
|
||||||
len(s.Norms[i])*4 /* size of float32 */) + |
|
||||||
(segment.SizeOfSlice * 2) |
|
||||||
} |
|
||||||
sizeInBytes += (segment.SizeOfSlice * 2) |
|
||||||
|
|
||||||
// Location data
|
|
||||||
for i := 0; i < len(s.Locfields); i++ { |
|
||||||
sizeInBytes += uint64(len(s.Locfields[i])*2 /* size of uint16 */ + |
|
||||||
len(s.Locstarts[i])*8 /* size of uint64 */ + |
|
||||||
len(s.Locends[i])*8 /* size of uint64 */ + |
|
||||||
len(s.Locpos[i])*8 /* size of uint64 */) |
|
||||||
|
|
||||||
for j := 0; j < len(s.Locarraypos[i]); j++ { |
|
||||||
sizeInBytes += uint64(len(s.Locarraypos[i][j])*8 /* size of uint64 */) + |
|
||||||
segment.SizeOfSlice |
|
||||||
} |
|
||||||
|
|
||||||
sizeInBytes += (segment.SizeOfSlice * 5) |
|
||||||
} |
|
||||||
sizeInBytes += (segment.SizeOfSlice * 5) |
|
||||||
|
|
||||||
// Stored data
|
|
||||||
for i := 0; i < len(s.Stored); i++ { |
|
||||||
for _, v := range s.Stored[i] { |
|
||||||
sizeInBytes += uint64(2 /* size of uint16 */) |
|
||||||
for _, arr := range v { |
|
||||||
sizeInBytes += uint64(len(arr)) + segment.SizeOfSlice |
|
||||||
} |
|
||||||
sizeInBytes += segment.SizeOfSlice |
|
||||||
} |
|
||||||
|
|
||||||
for _, v := range s.StoredTypes[i] { |
|
||||||
sizeInBytes += uint64(2 /* size of uint16 */ +len(v)) + segment.SizeOfSlice |
|
||||||
} |
|
||||||
|
|
||||||
for _, v := range s.StoredPos[i] { |
|
||||||
sizeInBytes += uint64(2 /* size of uint16 */) |
|
||||||
for _, arr := range v { |
|
||||||
sizeInBytes += uint64(len(arr)*8 /* size of uint64 */) + |
|
||||||
segment.SizeOfSlice |
|
||||||
} |
|
||||||
sizeInBytes += segment.SizeOfSlice |
|
||||||
} |
|
||||||
|
|
||||||
// overhead from map(s) within Stored, StoredTypes, StoredPos
|
|
||||||
sizeInBytes += (segment.SizeOfMap * 3) |
|
||||||
} |
|
||||||
// overhead from data structures: Stored, StoredTypes, StoredPos
|
|
||||||
sizeInBytes += (segment.SizeOfSlice * 3) |
|
||||||
|
|
||||||
// DocValueFields
|
|
||||||
sizeInBytes += uint64(len(s.DocValueFields)*3 /* size of uint16 + bool */) + |
|
||||||
segment.SizeOfMap |
|
||||||
|
|
||||||
// SizeInBytes
|
|
||||||
sizeInBytes += uint64(8) |
|
||||||
|
|
||||||
s.sizeInBytes = sizeInBytes |
|
||||||
} |
|
||||||
|
|
||||||
func (s *Segment) SizeInBytes() uint64 { |
|
||||||
return s.sizeInBytes |
|
||||||
} |
|
||||||
|
|
||||||
func (s *Segment) AddRef() { |
|
||||||
} |
|
||||||
|
|
||||||
func (s *Segment) DecRef() error { |
|
||||||
return nil |
|
||||||
} |
|
||||||
|
|
||||||
// Fields returns the field names used in this segment
|
|
||||||
func (s *Segment) Fields() []string { |
|
||||||
return s.FieldsInv |
|
||||||
} |
|
||||||
|
|
||||||
// VisitDocument invokes the DocFieldValueVistor for each stored field
|
|
||||||
// for the specified doc number
|
|
||||||
func (s *Segment) VisitDocument(num uint64, visitor segment.DocumentFieldValueVisitor) error { |
|
||||||
// ensure document number exists
|
|
||||||
if int(num) > len(s.Stored)-1 { |
|
||||||
return nil |
|
||||||
} |
|
||||||
docFields := s.Stored[int(num)] |
|
||||||
st := s.StoredTypes[int(num)] |
|
||||||
sp := s.StoredPos[int(num)] |
|
||||||
for field, values := range docFields { |
|
||||||
for i, value := range values { |
|
||||||
keepGoing := visitor(s.FieldsInv[field], st[field][i], value, sp[field][i]) |
|
||||||
if !keepGoing { |
|
||||||
return nil |
|
||||||
} |
|
||||||
} |
|
||||||
} |
|
||||||
return nil |
|
||||||
} |
|
||||||
|
|
||||||
func (s *Segment) getField(name string) (int, error) { |
|
||||||
fieldID, ok := s.FieldsMap[name] |
|
||||||
if !ok { |
|
||||||
return 0, fmt.Errorf("no field named %s", name) |
|
||||||
} |
|
||||||
return int(fieldID - 1), nil |
|
||||||
} |
|
||||||
|
|
||||||
// Dictionary returns the term dictionary for the specified field
|
|
||||||
func (s *Segment) Dictionary(field string) (segment.TermDictionary, error) { |
|
||||||
fieldID, err := s.getField(field) |
|
||||||
if err != nil { |
|
||||||
// no such field, return empty dictionary
|
|
||||||
return &segment.EmptyDictionary{}, nil |
|
||||||
} |
|
||||||
return &Dictionary{ |
|
||||||
segment: s, |
|
||||||
field: field, |
|
||||||
fieldID: uint16(fieldID), |
|
||||||
}, nil |
|
||||||
} |
|
||||||
|
|
||||||
// Count returns the number of documents in this segment
|
|
||||||
// (this has no notion of deleted docs)
|
|
||||||
func (s *Segment) Count() uint64 { |
|
||||||
return uint64(len(s.Stored)) |
|
||||||
} |
|
||||||
|
|
||||||
// DocNumbers returns a bitset corresponding to the doc numbers of all the
|
|
||||||
// provided _id strings
|
|
||||||
func (s *Segment) DocNumbers(ids []string) (*roaring.Bitmap, error) { |
|
||||||
rv := roaring.New() |
|
||||||
|
|
||||||
// guard against empty segment
|
|
||||||
if len(s.FieldsMap) > 0 { |
|
||||||
idDictionary := s.Dicts[idFieldID] |
|
||||||
|
|
||||||
for _, id := range ids { |
|
||||||
postingID := idDictionary[id] |
|
||||||
if postingID > 0 { |
|
||||||
rv.Or(s.Postings[postingID-1]) |
|
||||||
} |
|
||||||
} |
|
||||||
} |
|
||||||
return rv, nil |
|
||||||
} |
|
||||||
|
|
||||||
// Close releases all resources associated with this segment
|
|
||||||
func (s *Segment) Close() error { |
|
||||||
return nil |
|
||||||
} |
|
||||||
@ -0,0 +1,75 @@ |
|||||||
|
// Copyright (c) 2018 Couchbase, Inc.
|
||||||
|
//
|
||||||
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||||
|
// you may not use this file except in compliance with the License.
|
||||||
|
// You may obtain a copy of the License at
|
||||||
|
//
|
||||||
|
// http://www.apache.org/licenses/LICENSE-2.0
|
||||||
|
//
|
||||||
|
// Unless required by applicable law or agreed to in writing, software
|
||||||
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||||
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||||
|
// See the License for the specific language governing permissions and
|
||||||
|
// limitations under the License.
|
||||||
|
|
||||||
|
package segment |
||||||
|
|
||||||
|
import ( |
||||||
|
"regexp/syntax" |
||||||
|
|
||||||
|
"github.com/couchbase/vellum/regexp" |
||||||
|
) |
||||||
|
|
||||||
|
func ParseRegexp(pattern string) (a *regexp.Regexp, prefixBeg, prefixEnd []byte, err error) { |
||||||
|
// TODO: potential optimization where syntax.Regexp supports a Simplify() API?
|
||||||
|
|
||||||
|
parsed, err := syntax.Parse(pattern, syntax.Perl) |
||||||
|
if err != nil { |
||||||
|
return nil, nil, nil, err |
||||||
|
} |
||||||
|
|
||||||
|
re, err := regexp.NewParsedWithLimit(pattern, parsed, regexp.DefaultLimit) |
||||||
|
if err != nil { |
||||||
|
return nil, nil, nil, err |
||||||
|
} |
||||||
|
|
||||||
|
prefix := LiteralPrefix(parsed) |
||||||
|
if prefix != "" { |
||||||
|
prefixBeg := []byte(prefix) |
||||||
|
prefixEnd := IncrementBytes(prefixBeg) |
||||||
|
return re, prefixBeg, prefixEnd, nil |
||||||
|
} |
||||||
|
|
||||||
|
return re, nil, nil, nil |
||||||
|
} |
||||||
|
|
||||||
|
// Returns the literal prefix given the parse tree for a regexp
|
||||||
|
func LiteralPrefix(s *syntax.Regexp) string { |
||||||
|
// traverse the left-most branch in the parse tree as long as the
|
||||||
|
// node represents a concatenation
|
||||||
|
for s != nil && s.Op == syntax.OpConcat { |
||||||
|
if len(s.Sub) < 1 { |
||||||
|
return "" |
||||||
|
} |
||||||
|
|
||||||
|
s = s.Sub[0] |
||||||
|
} |
||||||
|
|
||||||
|
if s.Op == syntax.OpLiteral { |
||||||
|
return string(s.Rune) |
||||||
|
} |
||||||
|
|
||||||
|
return "" // no literal prefix
|
||||||
|
} |
||||||
|
|
||||||
|
func IncrementBytes(in []byte) []byte { |
||||||
|
rv := make([]byte, len(in)) |
||||||
|
copy(rv, in) |
||||||
|
for i := len(rv) - 1; i >= 0; i-- { |
||||||
|
rv[i] = rv[i] + 1 |
||||||
|
if rv[i] != 0 { |
||||||
|
return rv // didn't overflow, so stop
|
||||||
|
} |
||||||
|
} |
||||||
|
return nil // overflowed
|
||||||
|
} |
||||||
@ -0,0 +1,826 @@ |
|||||||
|
// Copyright (c) 2018 Couchbase, Inc.
|
||||||
|
//
|
||||||
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||||
|
// you may not use this file except in compliance with the License.
|
||||||
|
// You may obtain a copy of the License at
|
||||||
|
//
|
||||||
|
// http://www.apache.org/licenses/LICENSE-2.0
|
||||||
|
//
|
||||||
|
// Unless required by applicable law or agreed to in writing, software
|
||||||
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||||
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||||
|
// See the License for the specific language governing permissions and
|
||||||
|
// limitations under the License.
|
||||||
|
|
||||||
|
package zap |
||||||
|
|
||||||
|
import ( |
||||||
|
"bytes" |
||||||
|
"encoding/binary" |
||||||
|
"math" |
||||||
|
"sort" |
||||||
|
"sync" |
||||||
|
|
||||||
|
"github.com/RoaringBitmap/roaring" |
||||||
|
"github.com/blevesearch/bleve/analysis" |
||||||
|
"github.com/blevesearch/bleve/document" |
||||||
|
"github.com/blevesearch/bleve/index" |
||||||
|
"github.com/couchbase/vellum" |
||||||
|
"github.com/golang/snappy" |
||||||
|
) |
||||||
|
|
||||||
|
var NewSegmentBufferNumResultsBump int = 100 |
||||||
|
var NewSegmentBufferNumResultsFactor float64 = 1.0 |
||||||
|
var NewSegmentBufferAvgBytesPerDocFactor float64 = 1.0 |
||||||
|
|
||||||
|
// AnalysisResultsToSegmentBase produces an in-memory zap-encoded
|
||||||
|
// SegmentBase from analysis results
|
||||||
|
func AnalysisResultsToSegmentBase(results []*index.AnalysisResult, |
||||||
|
chunkFactor uint32) (*SegmentBase, uint64, error) { |
||||||
|
s := interimPool.Get().(*interim) |
||||||
|
|
||||||
|
var br bytes.Buffer |
||||||
|
if s.lastNumDocs > 0 { |
||||||
|
// use previous results to initialize the buf with an estimate
|
||||||
|
// size, but note that the interim instance comes from a
|
||||||
|
// global interimPool, so multiple scorch instances indexing
|
||||||
|
// different docs can lead to low quality estimates
|
||||||
|
estimateAvgBytesPerDoc := int(float64(s.lastOutSize/s.lastNumDocs) * |
||||||
|
NewSegmentBufferNumResultsFactor) |
||||||
|
estimateNumResults := int(float64(len(results)+NewSegmentBufferNumResultsBump) * |
||||||
|
NewSegmentBufferAvgBytesPerDocFactor) |
||||||
|
br.Grow(estimateAvgBytesPerDoc * estimateNumResults) |
||||||
|
} |
||||||
|
|
||||||
|
s.results = results |
||||||
|
s.chunkFactor = chunkFactor |
||||||
|
s.w = NewCountHashWriter(&br) |
||||||
|
|
||||||
|
storedIndexOffset, fieldsIndexOffset, fdvIndexOffset, dictOffsets, |
||||||
|
err := s.convert() |
||||||
|
if err != nil { |
||||||
|
return nil, uint64(0), err |
||||||
|
} |
||||||
|
|
||||||
|
sb, err := InitSegmentBase(br.Bytes(), s.w.Sum32(), chunkFactor, |
||||||
|
s.FieldsMap, s.FieldsInv, uint64(len(results)), |
||||||
|
storedIndexOffset, fieldsIndexOffset, fdvIndexOffset, dictOffsets) |
||||||
|
|
||||||
|
if err == nil && s.reset() == nil { |
||||||
|
s.lastNumDocs = len(results) |
||||||
|
s.lastOutSize = len(br.Bytes()) |
||||||
|
interimPool.Put(s) |
||||||
|
} |
||||||
|
|
||||||
|
return sb, uint64(len(br.Bytes())), err |
||||||
|
} |
||||||
|
|
||||||
|
var interimPool = sync.Pool{New: func() interface{} { return &interim{} }} |
||||||
|
|
||||||
|
// interim holds temporary working data used while converting from
|
||||||
|
// analysis results to a zap-encoded segment
|
||||||
|
type interim struct { |
||||||
|
results []*index.AnalysisResult |
||||||
|
|
||||||
|
chunkFactor uint32 |
||||||
|
|
||||||
|
w *CountHashWriter |
||||||
|
|
||||||
|
// FieldsMap adds 1 to field id to avoid zero value issues
|
||||||
|
// name -> field id + 1
|
||||||
|
FieldsMap map[string]uint16 |
||||||
|
|
||||||
|
// FieldsInv is the inverse of FieldsMap
|
||||||
|
// field id -> name
|
||||||
|
FieldsInv []string |
||||||
|
|
||||||
|
// Term dictionaries for each field
|
||||||
|
// field id -> term -> postings list id + 1
|
||||||
|
Dicts []map[string]uint64 |
||||||
|
|
||||||
|
// Terms for each field, where terms are sorted ascending
|
||||||
|
// field id -> []term
|
||||||
|
DictKeys [][]string |
||||||
|
|
||||||
|
// Fields whose IncludeDocValues is true
|
||||||
|
// field id -> bool
|
||||||
|
IncludeDocValues []bool |
||||||
|
|
||||||
|
// postings id -> bitmap of docNums
|
||||||
|
Postings []*roaring.Bitmap |
||||||
|
|
||||||
|
// postings id -> freq/norm's, one for each docNum in postings
|
||||||
|
FreqNorms [][]interimFreqNorm |
||||||
|
freqNormsBacking []interimFreqNorm |
||||||
|
|
||||||
|
// postings id -> locs, one for each freq
|
||||||
|
Locs [][]interimLoc |
||||||
|
locsBacking []interimLoc |
||||||
|
|
||||||
|
numTermsPerPostingsList []int // key is postings list id
|
||||||
|
numLocsPerPostingsList []int // key is postings list id
|
||||||
|
|
||||||
|
builder *vellum.Builder |
||||||
|
builderBuf bytes.Buffer |
||||||
|
|
||||||
|
metaBuf bytes.Buffer |
||||||
|
|
||||||
|
tmp0 []byte |
||||||
|
tmp1 []byte |
||||||
|
|
||||||
|
lastNumDocs int |
||||||
|
lastOutSize int |
||||||
|
} |
||||||
|
|
||||||
|
func (s *interim) reset() (err error) { |
||||||
|
s.results = nil |
||||||
|
s.chunkFactor = 0 |
||||||
|
s.w = nil |
||||||
|
s.FieldsMap = nil |
||||||
|
s.FieldsInv = nil |
||||||
|
for i := range s.Dicts { |
||||||
|
s.Dicts[i] = nil |
||||||
|
} |
||||||
|
s.Dicts = s.Dicts[:0] |
||||||
|
for i := range s.DictKeys { |
||||||
|
s.DictKeys[i] = s.DictKeys[i][:0] |
||||||
|
} |
||||||
|
s.DictKeys = s.DictKeys[:0] |
||||||
|
for i := range s.IncludeDocValues { |
||||||
|
s.IncludeDocValues[i] = false |
||||||
|
} |
||||||
|
s.IncludeDocValues = s.IncludeDocValues[:0] |
||||||
|
for _, idn := range s.Postings { |
||||||
|
idn.Clear() |
||||||
|
} |
||||||
|
s.Postings = s.Postings[:0] |
||||||
|
s.FreqNorms = s.FreqNorms[:0] |
||||||
|
for i := range s.freqNormsBacking { |
||||||
|
s.freqNormsBacking[i] = interimFreqNorm{} |
||||||
|
} |
||||||
|
s.freqNormsBacking = s.freqNormsBacking[:0] |
||||||
|
s.Locs = s.Locs[:0] |
||||||
|
for i := range s.locsBacking { |
||||||
|
s.locsBacking[i] = interimLoc{} |
||||||
|
} |
||||||
|
s.locsBacking = s.locsBacking[:0] |
||||||
|
s.numTermsPerPostingsList = s.numTermsPerPostingsList[:0] |
||||||
|
s.numLocsPerPostingsList = s.numLocsPerPostingsList[:0] |
||||||
|
s.builderBuf.Reset() |
||||||
|
if s.builder != nil { |
||||||
|
err = s.builder.Reset(&s.builderBuf) |
||||||
|
} |
||||||
|
s.metaBuf.Reset() |
||||||
|
s.tmp0 = s.tmp0[:0] |
||||||
|
s.tmp1 = s.tmp1[:0] |
||||||
|
s.lastNumDocs = 0 |
||||||
|
s.lastOutSize = 0 |
||||||
|
|
||||||
|
return err |
||||||
|
} |
||||||
|
|
||||||
|
func (s *interim) grabBuf(size int) []byte { |
||||||
|
buf := s.tmp0 |
||||||
|
if cap(buf) < size { |
||||||
|
buf = make([]byte, size) |
||||||
|
s.tmp0 = buf |
||||||
|
} |
||||||
|
return buf[0:size] |
||||||
|
} |
||||||
|
|
||||||
|
type interimStoredField struct { |
||||||
|
vals [][]byte |
||||||
|
typs []byte |
||||||
|
arrayposs [][]uint64 // array positions
|
||||||
|
} |
||||||
|
|
||||||
|
type interimFreqNorm struct { |
||||||
|
freq uint64 |
||||||
|
norm float32 |
||||||
|
numLocs int |
||||||
|
} |
||||||
|
|
||||||
|
type interimLoc struct { |
||||||
|
fieldID uint16 |
||||||
|
pos uint64 |
||||||
|
start uint64 |
||||||
|
end uint64 |
||||||
|
arrayposs []uint64 |
||||||
|
} |
||||||
|
|
||||||
|
func (s *interim) convert() (uint64, uint64, uint64, []uint64, error) { |
||||||
|
s.FieldsMap = map[string]uint16{} |
||||||
|
|
||||||
|
s.getOrDefineField("_id") // _id field is fieldID 0
|
||||||
|
|
||||||
|
for _, result := range s.results { |
||||||
|
for _, field := range result.Document.CompositeFields { |
||||||
|
s.getOrDefineField(field.Name()) |
||||||
|
} |
||||||
|
for _, field := range result.Document.Fields { |
||||||
|
s.getOrDefineField(field.Name()) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
sort.Strings(s.FieldsInv[1:]) // keep _id as first field
|
||||||
|
|
||||||
|
for fieldID, fieldName := range s.FieldsInv { |
||||||
|
s.FieldsMap[fieldName] = uint16(fieldID + 1) |
||||||
|
} |
||||||
|
|
||||||
|
if cap(s.IncludeDocValues) >= len(s.FieldsInv) { |
||||||
|
s.IncludeDocValues = s.IncludeDocValues[:len(s.FieldsInv)] |
||||||
|
} else { |
||||||
|
s.IncludeDocValues = make([]bool, len(s.FieldsInv)) |
||||||
|
} |
||||||
|
|
||||||
|
s.prepareDicts() |
||||||
|
|
||||||
|
for _, dict := range s.DictKeys { |
||||||
|
sort.Strings(dict) |
||||||
|
} |
||||||
|
|
||||||
|
s.processDocuments() |
||||||
|
|
||||||
|
storedIndexOffset, err := s.writeStoredFields() |
||||||
|
if err != nil { |
||||||
|
return 0, 0, 0, nil, err |
||||||
|
} |
||||||
|
|
||||||
|
var fdvIndexOffset uint64 |
||||||
|
var dictOffsets []uint64 |
||||||
|
|
||||||
|
if len(s.results) > 0 { |
||||||
|
fdvIndexOffset, dictOffsets, err = s.writeDicts() |
||||||
|
if err != nil { |
||||||
|
return 0, 0, 0, nil, err |
||||||
|
} |
||||||
|
} else { |
||||||
|
dictOffsets = make([]uint64, len(s.FieldsInv)) |
||||||
|
} |
||||||
|
|
||||||
|
fieldsIndexOffset, err := persistFields(s.FieldsInv, s.w, dictOffsets) |
||||||
|
if err != nil { |
||||||
|
return 0, 0, 0, nil, err |
||||||
|
} |
||||||
|
|
||||||
|
return storedIndexOffset, fieldsIndexOffset, fdvIndexOffset, dictOffsets, nil |
||||||
|
} |
||||||
|
|
||||||
|
func (s *interim) getOrDefineField(fieldName string) int { |
||||||
|
fieldIDPlus1, exists := s.FieldsMap[fieldName] |
||||||
|
if !exists { |
||||||
|
fieldIDPlus1 = uint16(len(s.FieldsInv) + 1) |
||||||
|
s.FieldsMap[fieldName] = fieldIDPlus1 |
||||||
|
s.FieldsInv = append(s.FieldsInv, fieldName) |
||||||
|
|
||||||
|
s.Dicts = append(s.Dicts, make(map[string]uint64)) |
||||||
|
|
||||||
|
n := len(s.DictKeys) |
||||||
|
if n < cap(s.DictKeys) { |
||||||
|
s.DictKeys = s.DictKeys[:n+1] |
||||||
|
s.DictKeys[n] = s.DictKeys[n][:0] |
||||||
|
} else { |
||||||
|
s.DictKeys = append(s.DictKeys, []string(nil)) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
return int(fieldIDPlus1 - 1) |
||||||
|
} |
||||||
|
|
||||||
|
// fill Dicts and DictKeys from analysis results
|
||||||
|
func (s *interim) prepareDicts() { |
||||||
|
var pidNext int |
||||||
|
|
||||||
|
var totTFs int |
||||||
|
var totLocs int |
||||||
|
|
||||||
|
visitField := func(fieldID uint16, tfs analysis.TokenFrequencies) { |
||||||
|
dict := s.Dicts[fieldID] |
||||||
|
dictKeys := s.DictKeys[fieldID] |
||||||
|
|
||||||
|
for term, tf := range tfs { |
||||||
|
pidPlus1, exists := dict[term] |
||||||
|
if !exists { |
||||||
|
pidNext++ |
||||||
|
pidPlus1 = uint64(pidNext) |
||||||
|
|
||||||
|
dict[term] = pidPlus1 |
||||||
|
dictKeys = append(dictKeys, term) |
||||||
|
|
||||||
|
s.numTermsPerPostingsList = append(s.numTermsPerPostingsList, 0) |
||||||
|
s.numLocsPerPostingsList = append(s.numLocsPerPostingsList, 0) |
||||||
|
} |
||||||
|
|
||||||
|
pid := pidPlus1 - 1 |
||||||
|
|
||||||
|
s.numTermsPerPostingsList[pid] += 1 |
||||||
|
s.numLocsPerPostingsList[pid] += len(tf.Locations) |
||||||
|
|
||||||
|
totLocs += len(tf.Locations) |
||||||
|
} |
||||||
|
|
||||||
|
totTFs += len(tfs) |
||||||
|
|
||||||
|
s.DictKeys[fieldID] = dictKeys |
||||||
|
} |
||||||
|
|
||||||
|
for _, result := range s.results { |
||||||
|
// walk each composite field
|
||||||
|
for _, field := range result.Document.CompositeFields { |
||||||
|
fieldID := uint16(s.getOrDefineField(field.Name())) |
||||||
|
_, tf := field.Analyze() |
||||||
|
visitField(fieldID, tf) |
||||||
|
} |
||||||
|
|
||||||
|
// walk each field
|
||||||
|
for i, field := range result.Document.Fields { |
||||||
|
fieldID := uint16(s.getOrDefineField(field.Name())) |
||||||
|
tf := result.Analyzed[i] |
||||||
|
visitField(fieldID, tf) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
numPostingsLists := pidNext |
||||||
|
|
||||||
|
if cap(s.Postings) >= numPostingsLists { |
||||||
|
s.Postings = s.Postings[:numPostingsLists] |
||||||
|
} else { |
||||||
|
postings := make([]*roaring.Bitmap, numPostingsLists) |
||||||
|
copy(postings, s.Postings[:cap(s.Postings)]) |
||||||
|
for i := 0; i < numPostingsLists; i++ { |
||||||
|
if postings[i] == nil { |
||||||
|
postings[i] = roaring.New() |
||||||
|
} |
||||||
|
} |
||||||
|
s.Postings = postings |
||||||
|
} |
||||||
|
|
||||||
|
if cap(s.FreqNorms) >= numPostingsLists { |
||||||
|
s.FreqNorms = s.FreqNorms[:numPostingsLists] |
||||||
|
} else { |
||||||
|
s.FreqNorms = make([][]interimFreqNorm, numPostingsLists) |
||||||
|
} |
||||||
|
|
||||||
|
if cap(s.freqNormsBacking) >= totTFs { |
||||||
|
s.freqNormsBacking = s.freqNormsBacking[:totTFs] |
||||||
|
} else { |
||||||
|
s.freqNormsBacking = make([]interimFreqNorm, totTFs) |
||||||
|
} |
||||||
|
|
||||||
|
freqNormsBacking := s.freqNormsBacking |
||||||
|
for pid, numTerms := range s.numTermsPerPostingsList { |
||||||
|
s.FreqNorms[pid] = freqNormsBacking[0:0] |
||||||
|
freqNormsBacking = freqNormsBacking[numTerms:] |
||||||
|
} |
||||||
|
|
||||||
|
if cap(s.Locs) >= numPostingsLists { |
||||||
|
s.Locs = s.Locs[:numPostingsLists] |
||||||
|
} else { |
||||||
|
s.Locs = make([][]interimLoc, numPostingsLists) |
||||||
|
} |
||||||
|
|
||||||
|
if cap(s.locsBacking) >= totLocs { |
||||||
|
s.locsBacking = s.locsBacking[:totLocs] |
||||||
|
} else { |
||||||
|
s.locsBacking = make([]interimLoc, totLocs) |
||||||
|
} |
||||||
|
|
||||||
|
locsBacking := s.locsBacking |
||||||
|
for pid, numLocs := range s.numLocsPerPostingsList { |
||||||
|
s.Locs[pid] = locsBacking[0:0] |
||||||
|
locsBacking = locsBacking[numLocs:] |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
func (s *interim) processDocuments() { |
||||||
|
numFields := len(s.FieldsInv) |
||||||
|
reuseFieldLens := make([]int, numFields) |
||||||
|
reuseFieldTFs := make([]analysis.TokenFrequencies, numFields) |
||||||
|
|
||||||
|
for docNum, result := range s.results { |
||||||
|
for i := 0; i < numFields; i++ { // clear these for reuse
|
||||||
|
reuseFieldLens[i] = 0 |
||||||
|
reuseFieldTFs[i] = nil |
||||||
|
} |
||||||
|
|
||||||
|
s.processDocument(uint64(docNum), result, |
||||||
|
reuseFieldLens, reuseFieldTFs) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
func (s *interim) processDocument(docNum uint64, |
||||||
|
result *index.AnalysisResult, |
||||||
|
fieldLens []int, fieldTFs []analysis.TokenFrequencies) { |
||||||
|
visitField := func(fieldID uint16, fieldName string, |
||||||
|
ln int, tf analysis.TokenFrequencies) { |
||||||
|
fieldLens[fieldID] += ln |
||||||
|
|
||||||
|
existingFreqs := fieldTFs[fieldID] |
||||||
|
if existingFreqs != nil { |
||||||
|
existingFreqs.MergeAll(fieldName, tf) |
||||||
|
} else { |
||||||
|
fieldTFs[fieldID] = tf |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
// walk each composite field
|
||||||
|
for _, field := range result.Document.CompositeFields { |
||||||
|
fieldID := uint16(s.getOrDefineField(field.Name())) |
||||||
|
ln, tf := field.Analyze() |
||||||
|
visitField(fieldID, field.Name(), ln, tf) |
||||||
|
} |
||||||
|
|
||||||
|
// walk each field
|
||||||
|
for i, field := range result.Document.Fields { |
||||||
|
fieldID := uint16(s.getOrDefineField(field.Name())) |
||||||
|
ln := result.Length[i] |
||||||
|
tf := result.Analyzed[i] |
||||||
|
visitField(fieldID, field.Name(), ln, tf) |
||||||
|
} |
||||||
|
|
||||||
|
// now that it's been rolled up into fieldTFs, walk that
|
||||||
|
for fieldID, tfs := range fieldTFs { |
||||||
|
dict := s.Dicts[fieldID] |
||||||
|
norm := float32(1.0 / math.Sqrt(float64(fieldLens[fieldID]))) |
||||||
|
|
||||||
|
for term, tf := range tfs { |
||||||
|
pid := dict[term] - 1 |
||||||
|
bs := s.Postings[pid] |
||||||
|
bs.Add(uint32(docNum)) |
||||||
|
|
||||||
|
s.FreqNorms[pid] = append(s.FreqNorms[pid], |
||||||
|
interimFreqNorm{ |
||||||
|
freq: uint64(tf.Frequency()), |
||||||
|
norm: norm, |
||||||
|
numLocs: len(tf.Locations), |
||||||
|
}) |
||||||
|
|
||||||
|
if len(tf.Locations) > 0 { |
||||||
|
locs := s.Locs[pid] |
||||||
|
|
||||||
|
for _, loc := range tf.Locations { |
||||||
|
var locf = uint16(fieldID) |
||||||
|
if loc.Field != "" { |
||||||
|
locf = uint16(s.getOrDefineField(loc.Field)) |
||||||
|
} |
||||||
|
var arrayposs []uint64 |
||||||
|
if len(loc.ArrayPositions) > 0 { |
||||||
|
arrayposs = loc.ArrayPositions |
||||||
|
} |
||||||
|
locs = append(locs, interimLoc{ |
||||||
|
fieldID: locf, |
||||||
|
pos: uint64(loc.Position), |
||||||
|
start: uint64(loc.Start), |
||||||
|
end: uint64(loc.End), |
||||||
|
arrayposs: arrayposs, |
||||||
|
}) |
||||||
|
} |
||||||
|
|
||||||
|
s.Locs[pid] = locs |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
func (s *interim) writeStoredFields() ( |
||||||
|
storedIndexOffset uint64, err error) { |
||||||
|
varBuf := make([]byte, binary.MaxVarintLen64) |
||||||
|
metaEncode := func(val uint64) (int, error) { |
||||||
|
wb := binary.PutUvarint(varBuf, val) |
||||||
|
return s.metaBuf.Write(varBuf[:wb]) |
||||||
|
} |
||||||
|
|
||||||
|
data, compressed := s.tmp0[:0], s.tmp1[:0] |
||||||
|
defer func() { s.tmp0, s.tmp1 = data, compressed }() |
||||||
|
|
||||||
|
// keyed by docNum
|
||||||
|
docStoredOffsets := make([]uint64, len(s.results)) |
||||||
|
|
||||||
|
// keyed by fieldID, for the current doc in the loop
|
||||||
|
docStoredFields := map[uint16]interimStoredField{} |
||||||
|
|
||||||
|
for docNum, result := range s.results { |
||||||
|
for fieldID := range docStoredFields { // reset for next doc
|
||||||
|
delete(docStoredFields, fieldID) |
||||||
|
} |
||||||
|
|
||||||
|
for _, field := range result.Document.Fields { |
||||||
|
fieldID := uint16(s.getOrDefineField(field.Name())) |
||||||
|
|
||||||
|
opts := field.Options() |
||||||
|
|
||||||
|
if opts.IsStored() { |
||||||
|
isf := docStoredFields[fieldID] |
||||||
|
isf.vals = append(isf.vals, field.Value()) |
||||||
|
isf.typs = append(isf.typs, encodeFieldType(field)) |
||||||
|
isf.arrayposs = append(isf.arrayposs, field.ArrayPositions()) |
||||||
|
docStoredFields[fieldID] = isf |
||||||
|
} |
||||||
|
|
||||||
|
if opts.IncludeDocValues() { |
||||||
|
s.IncludeDocValues[fieldID] = true |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
var curr int |
||||||
|
|
||||||
|
s.metaBuf.Reset() |
||||||
|
data = data[:0] |
||||||
|
|
||||||
|
// _id field special case optimizes ExternalID() lookups
|
||||||
|
idFieldVal := docStoredFields[uint16(0)].vals[0] |
||||||
|
_, err = metaEncode(uint64(len(idFieldVal))) |
||||||
|
if err != nil { |
||||||
|
return 0, err |
||||||
|
} |
||||||
|
|
||||||
|
// handle non-"_id" fields
|
||||||
|
for fieldID := 1; fieldID < len(s.FieldsInv); fieldID++ { |
||||||
|
isf, exists := docStoredFields[uint16(fieldID)] |
||||||
|
if exists { |
||||||
|
curr, data, err = persistStoredFieldValues( |
||||||
|
fieldID, isf.vals, isf.typs, isf.arrayposs, |
||||||
|
curr, metaEncode, data) |
||||||
|
if err != nil { |
||||||
|
return 0, err |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
metaBytes := s.metaBuf.Bytes() |
||||||
|
|
||||||
|
compressed = snappy.Encode(compressed[:cap(compressed)], data) |
||||||
|
|
||||||
|
docStoredOffsets[docNum] = uint64(s.w.Count()) |
||||||
|
|
||||||
|
_, err := writeUvarints(s.w, |
||||||
|
uint64(len(metaBytes)), |
||||||
|
uint64(len(idFieldVal)+len(compressed))) |
||||||
|
if err != nil { |
||||||
|
return 0, err |
||||||
|
} |
||||||
|
|
||||||
|
_, err = s.w.Write(metaBytes) |
||||||
|
if err != nil { |
||||||
|
return 0, err |
||||||
|
} |
||||||
|
|
||||||
|
_, err = s.w.Write(idFieldVal) |
||||||
|
if err != nil { |
||||||
|
return 0, err |
||||||
|
} |
||||||
|
|
||||||
|
_, err = s.w.Write(compressed) |
||||||
|
if err != nil { |
||||||
|
return 0, err |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
storedIndexOffset = uint64(s.w.Count()) |
||||||
|
|
||||||
|
for _, docStoredOffset := range docStoredOffsets { |
||||||
|
err = binary.Write(s.w, binary.BigEndian, docStoredOffset) |
||||||
|
if err != nil { |
||||||
|
return 0, err |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
return storedIndexOffset, nil |
||||||
|
} |
||||||
|
|
||||||
|
func (s *interim) writeDicts() (fdvIndexOffset uint64, dictOffsets []uint64, err error) { |
||||||
|
dictOffsets = make([]uint64, len(s.FieldsInv)) |
||||||
|
|
||||||
|
fdvOffsetsStart := make([]uint64, len(s.FieldsInv)) |
||||||
|
fdvOffsetsEnd := make([]uint64, len(s.FieldsInv)) |
||||||
|
|
||||||
|
buf := s.grabBuf(binary.MaxVarintLen64) |
||||||
|
|
||||||
|
tfEncoder := newChunkedIntCoder(uint64(s.chunkFactor), uint64(len(s.results)-1)) |
||||||
|
locEncoder := newChunkedIntCoder(uint64(s.chunkFactor), uint64(len(s.results)-1)) |
||||||
|
fdvEncoder := newChunkedContentCoder(uint64(s.chunkFactor), uint64(len(s.results)-1), s.w, false) |
||||||
|
|
||||||
|
var docTermMap [][]byte |
||||||
|
|
||||||
|
if s.builder == nil { |
||||||
|
s.builder, err = vellum.New(&s.builderBuf, nil) |
||||||
|
if err != nil { |
||||||
|
return 0, nil, err |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
for fieldID, terms := range s.DictKeys { |
||||||
|
if cap(docTermMap) < len(s.results) { |
||||||
|
docTermMap = make([][]byte, len(s.results)) |
||||||
|
} else { |
||||||
|
docTermMap = docTermMap[0:len(s.results)] |
||||||
|
for docNum := range docTermMap { // reset the docTermMap
|
||||||
|
docTermMap[docNum] = docTermMap[docNum][:0] |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
dict := s.Dicts[fieldID] |
||||||
|
|
||||||
|
for _, term := range terms { // terms are already sorted
|
||||||
|
pid := dict[term] - 1 |
||||||
|
|
||||||
|
postingsBS := s.Postings[pid] |
||||||
|
|
||||||
|
freqNorms := s.FreqNorms[pid] |
||||||
|
freqNormOffset := 0 |
||||||
|
|
||||||
|
locs := s.Locs[pid] |
||||||
|
locOffset := 0 |
||||||
|
|
||||||
|
postingsItr := postingsBS.Iterator() |
||||||
|
for postingsItr.HasNext() { |
||||||
|
docNum := uint64(postingsItr.Next()) |
||||||
|
|
||||||
|
freqNorm := freqNorms[freqNormOffset] |
||||||
|
|
||||||
|
err = tfEncoder.Add(docNum, |
||||||
|
encodeFreqHasLocs(freqNorm.freq, freqNorm.numLocs > 0), |
||||||
|
uint64(math.Float32bits(freqNorm.norm))) |
||||||
|
if err != nil { |
||||||
|
return 0, nil, err |
||||||
|
} |
||||||
|
|
||||||
|
if freqNorm.numLocs > 0 { |
||||||
|
numBytesLocs := 0 |
||||||
|
for _, loc := range locs[locOffset : locOffset+freqNorm.numLocs] { |
||||||
|
numBytesLocs += totalUvarintBytes( |
||||||
|
uint64(loc.fieldID), loc.pos, loc.start, loc.end, |
||||||
|
uint64(len(loc.arrayposs)), loc.arrayposs) |
||||||
|
} |
||||||
|
|
||||||
|
err = locEncoder.Add(docNum, uint64(numBytesLocs)) |
||||||
|
if err != nil { |
||||||
|
return 0, nil, err |
||||||
|
} |
||||||
|
|
||||||
|
for _, loc := range locs[locOffset : locOffset+freqNorm.numLocs] { |
||||||
|
err = locEncoder.Add(docNum, |
||||||
|
uint64(loc.fieldID), loc.pos, loc.start, loc.end, |
||||||
|
uint64(len(loc.arrayposs))) |
||||||
|
if err != nil { |
||||||
|
return 0, nil, err |
||||||
|
} |
||||||
|
|
||||||
|
err = locEncoder.Add(docNum, loc.arrayposs...) |
||||||
|
if err != nil { |
||||||
|
return 0, nil, err |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
locOffset += freqNorm.numLocs |
||||||
|
} |
||||||
|
|
||||||
|
freqNormOffset++ |
||||||
|
|
||||||
|
docTermMap[docNum] = append( |
||||||
|
append(docTermMap[docNum], term...), |
||||||
|
termSeparator) |
||||||
|
} |
||||||
|
|
||||||
|
tfEncoder.Close() |
||||||
|
locEncoder.Close() |
||||||
|
|
||||||
|
postingsOffset, err := |
||||||
|
writePostings(postingsBS, tfEncoder, locEncoder, nil, s.w, buf) |
||||||
|
if err != nil { |
||||||
|
return 0, nil, err |
||||||
|
} |
||||||
|
|
||||||
|
if postingsOffset > uint64(0) { |
||||||
|
err = s.builder.Insert([]byte(term), postingsOffset) |
||||||
|
if err != nil { |
||||||
|
return 0, nil, err |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
tfEncoder.Reset() |
||||||
|
locEncoder.Reset() |
||||||
|
} |
||||||
|
|
||||||
|
err = s.builder.Close() |
||||||
|
if err != nil { |
||||||
|
return 0, nil, err |
||||||
|
} |
||||||
|
|
||||||
|
// record where this dictionary starts
|
||||||
|
dictOffsets[fieldID] = uint64(s.w.Count()) |
||||||
|
|
||||||
|
vellumData := s.builderBuf.Bytes() |
||||||
|
|
||||||
|
// write out the length of the vellum data
|
||||||
|
n := binary.PutUvarint(buf, uint64(len(vellumData))) |
||||||
|
_, err = s.w.Write(buf[:n]) |
||||||
|
if err != nil { |
||||||
|
return 0, nil, err |
||||||
|
} |
||||||
|
|
||||||
|
// write this vellum to disk
|
||||||
|
_, err = s.w.Write(vellumData) |
||||||
|
if err != nil { |
||||||
|
return 0, nil, err |
||||||
|
} |
||||||
|
|
||||||
|
// reset vellum for reuse
|
||||||
|
s.builderBuf.Reset() |
||||||
|
|
||||||
|
err = s.builder.Reset(&s.builderBuf) |
||||||
|
if err != nil { |
||||||
|
return 0, nil, err |
||||||
|
} |
||||||
|
|
||||||
|
// write the field doc values
|
||||||
|
if s.IncludeDocValues[fieldID] { |
||||||
|
for docNum, docTerms := range docTermMap { |
||||||
|
if len(docTerms) > 0 { |
||||||
|
err = fdvEncoder.Add(uint64(docNum), docTerms) |
||||||
|
if err != nil { |
||||||
|
return 0, nil, err |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
err = fdvEncoder.Close() |
||||||
|
if err != nil { |
||||||
|
return 0, nil, err |
||||||
|
} |
||||||
|
|
||||||
|
fdvOffsetsStart[fieldID] = uint64(s.w.Count()) |
||||||
|
|
||||||
|
_, err = fdvEncoder.Write() |
||||||
|
if err != nil { |
||||||
|
return 0, nil, err |
||||||
|
} |
||||||
|
|
||||||
|
fdvOffsetsEnd[fieldID] = uint64(s.w.Count()) |
||||||
|
|
||||||
|
fdvEncoder.Reset() |
||||||
|
} else { |
||||||
|
fdvOffsetsStart[fieldID] = fieldNotUninverted |
||||||
|
fdvOffsetsEnd[fieldID] = fieldNotUninverted |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
fdvIndexOffset = uint64(s.w.Count()) |
||||||
|
|
||||||
|
for i := 0; i < len(fdvOffsetsStart); i++ { |
||||||
|
n := binary.PutUvarint(buf, fdvOffsetsStart[i]) |
||||||
|
_, err := s.w.Write(buf[:n]) |
||||||
|
if err != nil { |
||||||
|
return 0, nil, err |
||||||
|
} |
||||||
|
n = binary.PutUvarint(buf, fdvOffsetsEnd[i]) |
||||||
|
_, err = s.w.Write(buf[:n]) |
||||||
|
if err != nil { |
||||||
|
return 0, nil, err |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
return fdvIndexOffset, dictOffsets, nil |
||||||
|
} |
||||||
|
|
||||||
|
func encodeFieldType(f document.Field) byte { |
||||||
|
fieldType := byte('x') |
||||||
|
switch f.(type) { |
||||||
|
case *document.TextField: |
||||||
|
fieldType = 't' |
||||||
|
case *document.NumericField: |
||||||
|
fieldType = 'n' |
||||||
|
case *document.DateTimeField: |
||||||
|
fieldType = 'd' |
||||||
|
case *document.BooleanField: |
||||||
|
fieldType = 'b' |
||||||
|
case *document.GeoPointField: |
||||||
|
fieldType = 'g' |
||||||
|
case *document.CompositeField: |
||||||
|
fieldType = 'c' |
||||||
|
} |
||||||
|
return fieldType |
||||||
|
} |
||||||
|
|
||||||
|
// returns the total # of bytes needed to encode the given uint64's
|
||||||
|
// into binary.PutUVarint() encoding
|
||||||
|
func totalUvarintBytes(a, b, c, d, e uint64, more []uint64) (n int) { |
||||||
|
n = numUvarintBytes(a) |
||||||
|
n += numUvarintBytes(b) |
||||||
|
n += numUvarintBytes(c) |
||||||
|
n += numUvarintBytes(d) |
||||||
|
n += numUvarintBytes(e) |
||||||
|
for _, v := range more { |
||||||
|
n += numUvarintBytes(v) |
||||||
|
} |
||||||
|
return n |
||||||
|
} |
||||||
|
|
||||||
|
// returns # of bytes needed to encode x in binary.PutUvarint() encoding
|
||||||
|
func numUvarintBytes(x uint64) (n int) { |
||||||
|
for x >= 0x80 { |
||||||
|
x >>= 7 |
||||||
|
n++ |
||||||
|
} |
||||||
|
return n + 1 |
||||||
|
} |
||||||
File diff suppressed because it is too large
Load Diff
343
vendor/github.com/blevesearch/bleve/search/searcher/search_disjunction_heap.go
generated
vendored
343
vendor/github.com/blevesearch/bleve/search/searcher/search_disjunction_heap.go
generated
vendored
@ -0,0 +1,343 @@ |
|||||||
|
// Copyright (c) 2018 Couchbase, Inc.
|
||||||
|
//
|
||||||
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||||
|
// you may not use this file except in compliance with the License.
|
||||||
|
// You may obtain a copy of the License at
|
||||||
|
//
|
||||||
|
// http://www.apache.org/licenses/LICENSE-2.0
|
||||||
|
//
|
||||||
|
// Unless required by applicable law or agreed to in writing, software
|
||||||
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||||
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||||
|
// See the License for the specific language governing permissions and
|
||||||
|
// limitations under the License.
|
||||||
|
|
||||||
|
package searcher |
||||||
|
|
||||||
|
import ( |
||||||
|
"bytes" |
||||||
|
"container/heap" |
||||||
|
"math" |
||||||
|
"reflect" |
||||||
|
|
||||||
|
"github.com/blevesearch/bleve/index" |
||||||
|
"github.com/blevesearch/bleve/search" |
||||||
|
"github.com/blevesearch/bleve/search/scorer" |
||||||
|
"github.com/blevesearch/bleve/size" |
||||||
|
) |
||||||
|
|
||||||
|
var reflectStaticSizeDisjunctionHeapSearcher int |
||||||
|
var reflectStaticSizeSearcherCurr int |
||||||
|
|
||||||
|
func init() { |
||||||
|
var dhs DisjunctionHeapSearcher |
||||||
|
reflectStaticSizeDisjunctionHeapSearcher = int(reflect.TypeOf(dhs).Size()) |
||||||
|
|
||||||
|
var sc SearcherCurr |
||||||
|
reflectStaticSizeSearcherCurr = int(reflect.TypeOf(sc).Size()) |
||||||
|
} |
||||||
|
|
||||||
|
type SearcherCurr struct { |
||||||
|
searcher search.Searcher |
||||||
|
curr *search.DocumentMatch |
||||||
|
} |
||||||
|
|
||||||
|
type DisjunctionHeapSearcher struct { |
||||||
|
indexReader index.IndexReader |
||||||
|
|
||||||
|
numSearchers int |
||||||
|
scorer *scorer.DisjunctionQueryScorer |
||||||
|
min int |
||||||
|
queryNorm float64 |
||||||
|
initialized bool |
||||||
|
searchers []search.Searcher |
||||||
|
heap []*SearcherCurr |
||||||
|
|
||||||
|
matching []*search.DocumentMatch |
||||||
|
matchingCurrs []*SearcherCurr |
||||||
|
} |
||||||
|
|
||||||
|
func newDisjunctionHeapSearcher(indexReader index.IndexReader, |
||||||
|
searchers []search.Searcher, min float64, options search.SearcherOptions, |
||||||
|
limit bool) ( |
||||||
|
*DisjunctionHeapSearcher, error) { |
||||||
|
if limit && tooManyClauses(len(searchers)) { |
||||||
|
return nil, tooManyClausesErr(len(searchers)) |
||||||
|
} |
||||||
|
|
||||||
|
// build our searcher
|
||||||
|
rv := DisjunctionHeapSearcher{ |
||||||
|
indexReader: indexReader, |
||||||
|
searchers: searchers, |
||||||
|
numSearchers: len(searchers), |
||||||
|
scorer: scorer.NewDisjunctionQueryScorer(options), |
||||||
|
min: int(min), |
||||||
|
matching: make([]*search.DocumentMatch, len(searchers)), |
||||||
|
matchingCurrs: make([]*SearcherCurr, len(searchers)), |
||||||
|
heap: make([]*SearcherCurr, 0, len(searchers)), |
||||||
|
} |
||||||
|
rv.computeQueryNorm() |
||||||
|
return &rv, nil |
||||||
|
} |
||||||
|
|
||||||
|
func (s *DisjunctionHeapSearcher) Size() int { |
||||||
|
sizeInBytes := reflectStaticSizeDisjunctionHeapSearcher + size.SizeOfPtr + |
||||||
|
s.scorer.Size() |
||||||
|
|
||||||
|
for _, entry := range s.searchers { |
||||||
|
sizeInBytes += entry.Size() |
||||||
|
} |
||||||
|
|
||||||
|
for _, entry := range s.matching { |
||||||
|
if entry != nil { |
||||||
|
sizeInBytes += entry.Size() |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
// for matchingCurrs and heap, just use static size * len
|
||||||
|
// since searchers and document matches already counted above
|
||||||
|
sizeInBytes += len(s.matchingCurrs) * reflectStaticSizeSearcherCurr |
||||||
|
sizeInBytes += len(s.heap) * reflectStaticSizeSearcherCurr |
||||||
|
|
||||||
|
return sizeInBytes |
||||||
|
} |
||||||
|
|
||||||
|
func (s *DisjunctionHeapSearcher) computeQueryNorm() { |
||||||
|
// first calculate sum of squared weights
|
||||||
|
sumOfSquaredWeights := 0.0 |
||||||
|
for _, searcher := range s.searchers { |
||||||
|
sumOfSquaredWeights += searcher.Weight() |
||||||
|
} |
||||||
|
// now compute query norm from this
|
||||||
|
s.queryNorm = 1.0 / math.Sqrt(sumOfSquaredWeights) |
||||||
|
// finally tell all the downstream searchers the norm
|
||||||
|
for _, searcher := range s.searchers { |
||||||
|
searcher.SetQueryNorm(s.queryNorm) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
func (s *DisjunctionHeapSearcher) initSearchers(ctx *search.SearchContext) error { |
||||||
|
// alloc a single block of SearcherCurrs
|
||||||
|
block := make([]SearcherCurr, len(s.searchers)) |
||||||
|
|
||||||
|
// get all searchers pointing at their first match
|
||||||
|
for i, searcher := range s.searchers { |
||||||
|
curr, err := searcher.Next(ctx) |
||||||
|
if err != nil { |
||||||
|
return err |
||||||
|
} |
||||||
|
if curr != nil { |
||||||
|
block[i].searcher = searcher |
||||||
|
block[i].curr = curr |
||||||
|
heap.Push(s, &block[i]) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
err := s.updateMatches() |
||||||
|
if err != nil { |
||||||
|
return err |
||||||
|
} |
||||||
|
s.initialized = true |
||||||
|
return nil |
||||||
|
} |
||||||
|
|
||||||
|
func (s *DisjunctionHeapSearcher) updateMatches() error { |
||||||
|
matching := s.matching[:0] |
||||||
|
matchingCurrs := s.matchingCurrs[:0] |
||||||
|
|
||||||
|
if len(s.heap) > 0 { |
||||||
|
|
||||||
|
// top of the heap is our next hit
|
||||||
|
next := heap.Pop(s).(*SearcherCurr) |
||||||
|
matching = append(matching, next.curr) |
||||||
|
matchingCurrs = append(matchingCurrs, next) |
||||||
|
|
||||||
|
// now as long as top of heap matches, keep popping
|
||||||
|
for len(s.heap) > 0 && bytes.Compare(next.curr.IndexInternalID, s.heap[0].curr.IndexInternalID) == 0 { |
||||||
|
next = heap.Pop(s).(*SearcherCurr) |
||||||
|
matching = append(matching, next.curr) |
||||||
|
matchingCurrs = append(matchingCurrs, next) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
s.matching = matching |
||||||
|
s.matchingCurrs = matchingCurrs |
||||||
|
|
||||||
|
return nil |
||||||
|
} |
||||||
|
|
||||||
|
func (s *DisjunctionHeapSearcher) Weight() float64 { |
||||||
|
var rv float64 |
||||||
|
for _, searcher := range s.searchers { |
||||||
|
rv += searcher.Weight() |
||||||
|
} |
||||||
|
return rv |
||||||
|
} |
||||||
|
|
||||||
|
func (s *DisjunctionHeapSearcher) SetQueryNorm(qnorm float64) { |
||||||
|
for _, searcher := range s.searchers { |
||||||
|
searcher.SetQueryNorm(qnorm) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
func (s *DisjunctionHeapSearcher) Next(ctx *search.SearchContext) ( |
||||||
|
*search.DocumentMatch, error) { |
||||||
|
if !s.initialized { |
||||||
|
err := s.initSearchers(ctx) |
||||||
|
if err != nil { |
||||||
|
return nil, err |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
var rv *search.DocumentMatch |
||||||
|
found := false |
||||||
|
for !found && len(s.matching) > 0 { |
||||||
|
if len(s.matching) >= s.min { |
||||||
|
found = true |
||||||
|
// score this match
|
||||||
|
rv = s.scorer.Score(ctx, s.matching, len(s.matching), s.numSearchers) |
||||||
|
} |
||||||
|
|
||||||
|
// invoke next on all the matching searchers
|
||||||
|
for _, matchingCurr := range s.matchingCurrs { |
||||||
|
if matchingCurr.curr != rv { |
||||||
|
ctx.DocumentMatchPool.Put(matchingCurr.curr) |
||||||
|
} |
||||||
|
curr, err := matchingCurr.searcher.Next(ctx) |
||||||
|
if err != nil { |
||||||
|
return nil, err |
||||||
|
} |
||||||
|
if curr != nil { |
||||||
|
matchingCurr.curr = curr |
||||||
|
heap.Push(s, matchingCurr) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
err := s.updateMatches() |
||||||
|
if err != nil { |
||||||
|
return nil, err |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
return rv, nil |
||||||
|
} |
||||||
|
|
||||||
|
func (s *DisjunctionHeapSearcher) Advance(ctx *search.SearchContext, |
||||||
|
ID index.IndexInternalID) (*search.DocumentMatch, error) { |
||||||
|
if !s.initialized { |
||||||
|
err := s.initSearchers(ctx) |
||||||
|
if err != nil { |
||||||
|
return nil, err |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
// if there is anything in matching, toss it back onto the heap
|
||||||
|
for _, matchingCurr := range s.matchingCurrs { |
||||||
|
heap.Push(s, matchingCurr) |
||||||
|
} |
||||||
|
s.matching = s.matching[:0] |
||||||
|
s.matchingCurrs = s.matchingCurrs[:0] |
||||||
|
|
||||||
|
// find all searchers that actually need to be advanced
|
||||||
|
// advance them, using s.matchingCurrs as temp storage
|
||||||
|
for len(s.heap) > 0 && bytes.Compare(s.heap[0].curr.IndexInternalID, ID) < 0 { |
||||||
|
searcherCurr := heap.Pop(s).(*SearcherCurr) |
||||||
|
ctx.DocumentMatchPool.Put(searcherCurr.curr) |
||||||
|
curr, err := searcherCurr.searcher.Advance(ctx, ID) |
||||||
|
if err != nil { |
||||||
|
return nil, err |
||||||
|
} |
||||||
|
if curr != nil { |
||||||
|
searcherCurr.curr = curr |
||||||
|
s.matchingCurrs = append(s.matchingCurrs, searcherCurr) |
||||||
|
} |
||||||
|
} |
||||||
|
// now all of the searchers that we advanced have to be pushed back
|
||||||
|
for _, matchingCurr := range s.matchingCurrs { |
||||||
|
heap.Push(s, matchingCurr) |
||||||
|
} |
||||||
|
// reset our temp space
|
||||||
|
s.matchingCurrs = s.matchingCurrs[:0] |
||||||
|
|
||||||
|
err := s.updateMatches() |
||||||
|
if err != nil { |
||||||
|
return nil, err |
||||||
|
} |
||||||
|
|
||||||
|
return s.Next(ctx) |
||||||
|
} |
||||||
|
|
||||||
|
func (s *DisjunctionHeapSearcher) Count() uint64 { |
||||||
|
// for now return a worst case
|
||||||
|
var sum uint64 |
||||||
|
for _, searcher := range s.searchers { |
||||||
|
sum += searcher.Count() |
||||||
|
} |
||||||
|
return sum |
||||||
|
} |
||||||
|
|
||||||
|
func (s *DisjunctionHeapSearcher) Close() (rv error) { |
||||||
|
for _, searcher := range s.searchers { |
||||||
|
err := searcher.Close() |
||||||
|
if err != nil && rv == nil { |
||||||
|
rv = err |
||||||
|
} |
||||||
|
} |
||||||
|
return rv |
||||||
|
} |
||||||
|
|
||||||
|
func (s *DisjunctionHeapSearcher) Min() int { |
||||||
|
return s.min |
||||||
|
} |
||||||
|
|
||||||
|
func (s *DisjunctionHeapSearcher) DocumentMatchPoolSize() int { |
||||||
|
rv := len(s.searchers) |
||||||
|
for _, s := range s.searchers { |
||||||
|
rv += s.DocumentMatchPoolSize() |
||||||
|
} |
||||||
|
return rv |
||||||
|
} |
||||||
|
|
||||||
|
// a disjunction searcher implements the index.Optimizable interface
|
||||||
|
// but only activates on an edge case where the disjunction is a
|
||||||
|
// wrapper around a single Optimizable child searcher
|
||||||
|
func (s *DisjunctionHeapSearcher) Optimize(kind string, octx index.OptimizableContext) ( |
||||||
|
index.OptimizableContext, error) { |
||||||
|
if len(s.searchers) == 1 { |
||||||
|
o, ok := s.searchers[0].(index.Optimizable) |
||||||
|
if ok { |
||||||
|
return o.Optimize(kind, octx) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
return octx, nil |
||||||
|
} |
||||||
|
|
||||||
|
// heap impl
|
||||||
|
|
||||||
|
func (s *DisjunctionHeapSearcher) Len() int { return len(s.heap) } |
||||||
|
|
||||||
|
func (s *DisjunctionHeapSearcher) Less(i, j int) bool { |
||||||
|
if s.heap[i].curr == nil { |
||||||
|
return true |
||||||
|
} else if s.heap[j].curr == nil { |
||||||
|
return false |
||||||
|
} |
||||||
|
return bytes.Compare(s.heap[i].curr.IndexInternalID, s.heap[j].curr.IndexInternalID) < 0 |
||||||
|
} |
||||||
|
|
||||||
|
func (s *DisjunctionHeapSearcher) Swap(i, j int) { |
||||||
|
s.heap[i], s.heap[j] = s.heap[j], s.heap[i] |
||||||
|
} |
||||||
|
|
||||||
|
func (s *DisjunctionHeapSearcher) Push(x interface{}) { |
||||||
|
s.heap = append(s.heap, x.(*SearcherCurr)) |
||||||
|
} |
||||||
|
|
||||||
|
func (s *DisjunctionHeapSearcher) Pop() interface{} { |
||||||
|
old := s.heap |
||||||
|
n := len(old) |
||||||
|
x := old[n-1] |
||||||
|
s.heap = old[0 : n-1] |
||||||
|
return x |
||||||
|
} |
||||||
298
vendor/github.com/blevesearch/bleve/search/searcher/search_disjunction_slice.go
generated
vendored
298
vendor/github.com/blevesearch/bleve/search/searcher/search_disjunction_slice.go
generated
vendored
@ -0,0 +1,298 @@ |
|||||||
|
// Copyright (c) 2018 Couchbase, Inc.
|
||||||
|
//
|
||||||
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||||
|
// you may not use this file except in compliance with the License.
|
||||||
|
// You may obtain a copy of the License at
|
||||||
|
//
|
||||||
|
// http://www.apache.org/licenses/LICENSE-2.0
|
||||||
|
//
|
||||||
|
// Unless required by applicable law or agreed to in writing, software
|
||||||
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||||
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||||
|
// See the License for the specific language governing permissions and
|
||||||
|
// limitations under the License.
|
||||||
|
|
||||||
|
package searcher |
||||||
|
|
||||||
|
import ( |
||||||
|
"math" |
||||||
|
"reflect" |
||||||
|
"sort" |
||||||
|
|
||||||
|
"github.com/blevesearch/bleve/index" |
||||||
|
"github.com/blevesearch/bleve/search" |
||||||
|
"github.com/blevesearch/bleve/search/scorer" |
||||||
|
"github.com/blevesearch/bleve/size" |
||||||
|
) |
||||||
|
|
||||||
|
var reflectStaticSizeDisjunctionSliceSearcher int |
||||||
|
|
||||||
|
func init() { |
||||||
|
var ds DisjunctionSliceSearcher |
||||||
|
reflectStaticSizeDisjunctionSliceSearcher = int(reflect.TypeOf(ds).Size()) |
||||||
|
} |
||||||
|
|
||||||
|
type DisjunctionSliceSearcher struct { |
||||||
|
indexReader index.IndexReader |
||||||
|
searchers OrderedSearcherList |
||||||
|
numSearchers int |
||||||
|
queryNorm float64 |
||||||
|
currs []*search.DocumentMatch |
||||||
|
scorer *scorer.DisjunctionQueryScorer |
||||||
|
min int |
||||||
|
matching []*search.DocumentMatch |
||||||
|
matchingIdxs []int |
||||||
|
initialized bool |
||||||
|
} |
||||||
|
|
||||||
|
func newDisjunctionSliceSearcher(indexReader index.IndexReader, |
||||||
|
qsearchers []search.Searcher, min float64, options search.SearcherOptions, |
||||||
|
limit bool) ( |
||||||
|
*DisjunctionSliceSearcher, error) { |
||||||
|
if limit && tooManyClauses(len(qsearchers)) { |
||||||
|
return nil, tooManyClausesErr(len(qsearchers)) |
||||||
|
} |
||||||
|
// build the downstream searchers
|
||||||
|
searchers := make(OrderedSearcherList, len(qsearchers)) |
||||||
|
for i, searcher := range qsearchers { |
||||||
|
searchers[i] = searcher |
||||||
|
} |
||||||
|
// sort the searchers
|
||||||
|
sort.Sort(sort.Reverse(searchers)) |
||||||
|
// build our searcher
|
||||||
|
rv := DisjunctionSliceSearcher{ |
||||||
|
indexReader: indexReader, |
||||||
|
searchers: searchers, |
||||||
|
numSearchers: len(searchers), |
||||||
|
currs: make([]*search.DocumentMatch, len(searchers)), |
||||||
|
scorer: scorer.NewDisjunctionQueryScorer(options), |
||||||
|
min: int(min), |
||||||
|
matching: make([]*search.DocumentMatch, len(searchers)), |
||||||
|
matchingIdxs: make([]int, len(searchers)), |
||||||
|
} |
||||||
|
rv.computeQueryNorm() |
||||||
|
return &rv, nil |
||||||
|
} |
||||||
|
|
||||||
|
func (s *DisjunctionSliceSearcher) Size() int { |
||||||
|
sizeInBytes := reflectStaticSizeDisjunctionSliceSearcher + size.SizeOfPtr + |
||||||
|
s.scorer.Size() |
||||||
|
|
||||||
|
for _, entry := range s.searchers { |
||||||
|
sizeInBytes += entry.Size() |
||||||
|
} |
||||||
|
|
||||||
|
for _, entry := range s.currs { |
||||||
|
if entry != nil { |
||||||
|
sizeInBytes += entry.Size() |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
for _, entry := range s.matching { |
||||||
|
if entry != nil { |
||||||
|
sizeInBytes += entry.Size() |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
sizeInBytes += len(s.matchingIdxs) * size.SizeOfInt |
||||||
|
|
||||||
|
return sizeInBytes |
||||||
|
} |
||||||
|
|
||||||
|
func (s *DisjunctionSliceSearcher) computeQueryNorm() { |
||||||
|
// first calculate sum of squared weights
|
||||||
|
sumOfSquaredWeights := 0.0 |
||||||
|
for _, searcher := range s.searchers { |
||||||
|
sumOfSquaredWeights += searcher.Weight() |
||||||
|
} |
||||||
|
// now compute query norm from this
|
||||||
|
s.queryNorm = 1.0 / math.Sqrt(sumOfSquaredWeights) |
||||||
|
// finally tell all the downstream searchers the norm
|
||||||
|
for _, searcher := range s.searchers { |
||||||
|
searcher.SetQueryNorm(s.queryNorm) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
func (s *DisjunctionSliceSearcher) initSearchers(ctx *search.SearchContext) error { |
||||||
|
var err error |
||||||
|
// get all searchers pointing at their first match
|
||||||
|
for i, searcher := range s.searchers { |
||||||
|
if s.currs[i] != nil { |
||||||
|
ctx.DocumentMatchPool.Put(s.currs[i]) |
||||||
|
} |
||||||
|
s.currs[i], err = searcher.Next(ctx) |
||||||
|
if err != nil { |
||||||
|
return err |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
err = s.updateMatches() |
||||||
|
if err != nil { |
||||||
|
return err |
||||||
|
} |
||||||
|
|
||||||
|
s.initialized = true |
||||||
|
return nil |
||||||
|
} |
||||||
|
|
||||||
|
func (s *DisjunctionSliceSearcher) updateMatches() error { |
||||||
|
matching := s.matching[:0] |
||||||
|
matchingIdxs := s.matchingIdxs[:0] |
||||||
|
|
||||||
|
for i := 0; i < len(s.currs); i++ { |
||||||
|
curr := s.currs[i] |
||||||
|
if curr == nil { |
||||||
|
continue |
||||||
|
} |
||||||
|
|
||||||
|
if len(matching) > 0 { |
||||||
|
cmp := curr.IndexInternalID.Compare(matching[0].IndexInternalID) |
||||||
|
if cmp > 0 { |
||||||
|
continue |
||||||
|
} |
||||||
|
|
||||||
|
if cmp < 0 { |
||||||
|
matching = matching[:0] |
||||||
|
matchingIdxs = matchingIdxs[:0] |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
matching = append(matching, curr) |
||||||
|
matchingIdxs = append(matchingIdxs, i) |
||||||
|
} |
||||||
|
|
||||||
|
s.matching = matching |
||||||
|
s.matchingIdxs = matchingIdxs |
||||||
|
|
||||||
|
return nil |
||||||
|
} |
||||||
|
|
||||||
|
func (s *DisjunctionSliceSearcher) Weight() float64 { |
||||||
|
var rv float64 |
||||||
|
for _, searcher := range s.searchers { |
||||||
|
rv += searcher.Weight() |
||||||
|
} |
||||||
|
return rv |
||||||
|
} |
||||||
|
|
||||||
|
func (s *DisjunctionSliceSearcher) SetQueryNorm(qnorm float64) { |
||||||
|
for _, searcher := range s.searchers { |
||||||
|
searcher.SetQueryNorm(qnorm) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
func (s *DisjunctionSliceSearcher) Next(ctx *search.SearchContext) ( |
||||||
|
*search.DocumentMatch, error) { |
||||||
|
if !s.initialized { |
||||||
|
err := s.initSearchers(ctx) |
||||||
|
if err != nil { |
||||||
|
return nil, err |
||||||
|
} |
||||||
|
} |
||||||
|
var err error |
||||||
|
var rv *search.DocumentMatch |
||||||
|
|
||||||
|
found := false |
||||||
|
for !found && len(s.matching) > 0 { |
||||||
|
if len(s.matching) >= s.min { |
||||||
|
found = true |
||||||
|
// score this match
|
||||||
|
rv = s.scorer.Score(ctx, s.matching, len(s.matching), s.numSearchers) |
||||||
|
} |
||||||
|
|
||||||
|
// invoke next on all the matching searchers
|
||||||
|
for _, i := range s.matchingIdxs { |
||||||
|
searcher := s.searchers[i] |
||||||
|
if s.currs[i] != rv { |
||||||
|
ctx.DocumentMatchPool.Put(s.currs[i]) |
||||||
|
} |
||||||
|
s.currs[i], err = searcher.Next(ctx) |
||||||
|
if err != nil { |
||||||
|
return nil, err |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
err = s.updateMatches() |
||||||
|
if err != nil { |
||||||
|
return nil, err |
||||||
|
} |
||||||
|
} |
||||||
|
return rv, nil |
||||||
|
} |
||||||
|
|
||||||
|
func (s *DisjunctionSliceSearcher) Advance(ctx *search.SearchContext, |
||||||
|
ID index.IndexInternalID) (*search.DocumentMatch, error) { |
||||||
|
if !s.initialized { |
||||||
|
err := s.initSearchers(ctx) |
||||||
|
if err != nil { |
||||||
|
return nil, err |
||||||
|
} |
||||||
|
} |
||||||
|
// get all searchers pointing at their first match
|
||||||
|
var err error |
||||||
|
for i, searcher := range s.searchers { |
||||||
|
if s.currs[i] != nil { |
||||||
|
if s.currs[i].IndexInternalID.Compare(ID) >= 0 { |
||||||
|
continue |
||||||
|
} |
||||||
|
ctx.DocumentMatchPool.Put(s.currs[i]) |
||||||
|
} |
||||||
|
s.currs[i], err = searcher.Advance(ctx, ID) |
||||||
|
if err != nil { |
||||||
|
return nil, err |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
err = s.updateMatches() |
||||||
|
if err != nil { |
||||||
|
return nil, err |
||||||
|
} |
||||||
|
|
||||||
|
return s.Next(ctx) |
||||||
|
} |
||||||
|
|
||||||
|
func (s *DisjunctionSliceSearcher) Count() uint64 { |
||||||
|
// for now return a worst case
|
||||||
|
var sum uint64 |
||||||
|
for _, searcher := range s.searchers { |
||||||
|
sum += searcher.Count() |
||||||
|
} |
||||||
|
return sum |
||||||
|
} |
||||||
|
|
||||||
|
func (s *DisjunctionSliceSearcher) Close() (rv error) { |
||||||
|
for _, searcher := range s.searchers { |
||||||
|
err := searcher.Close() |
||||||
|
if err != nil && rv == nil { |
||||||
|
rv = err |
||||||
|
} |
||||||
|
} |
||||||
|
return rv |
||||||
|
} |
||||||
|
|
||||||
|
func (s *DisjunctionSliceSearcher) Min() int { |
||||||
|
return s.min |
||||||
|
} |
||||||
|
|
||||||
|
func (s *DisjunctionSliceSearcher) DocumentMatchPoolSize() int { |
||||||
|
rv := len(s.currs) |
||||||
|
for _, s := range s.searchers { |
||||||
|
rv += s.DocumentMatchPoolSize() |
||||||
|
} |
||||||
|
return rv |
||||||
|
} |
||||||
|
|
||||||
|
// a disjunction searcher implements the index.Optimizable interface
|
||||||
|
// but only activates on an edge case where the disjunction is a
|
||||||
|
// wrapper around a single Optimizable child searcher
|
||||||
|
func (s *DisjunctionSliceSearcher) Optimize(kind string, octx index.OptimizableContext) ( |
||||||
|
index.OptimizableContext, error) { |
||||||
|
if len(s.searchers) == 1 { |
||||||
|
o, ok := s.searchers[0].(index.Optimizable) |
||||||
|
if ok { |
||||||
|
return o.Optimize(kind, octx) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
return octx, nil |
||||||
|
} |
||||||
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in new issue