// CountLookup to count number entries for given set of keys.
func (c *GsiScanClient) CountLookup(
defnID uint64, values []common.SecondaryKey,
cons common.Consistency, vector *TsConsistency) (int64, error) {
// serialize match value.
equals := make([][]byte, 0, len(values))
for _, value := range values {
val, err := json.Marshal(value)
if err != nil {
return 0, err
}
equals = append(equals, val)
}
req := &protobuf.CountRequest{
DefnID: proto.Uint64(defnID),
Span: &protobuf.Span{Equals: equals},
Cons: proto.Uint32(uint32(cons)),
}
if vector != nil {
req.Vector = protobuf.NewTsConsistency(
vector.Vbnos, vector.Seqnos, vector.Vbuuids, vector.Crc64)
}
resp, err := c.doRequestResponse(req)
if err != nil {
return 0, err
}
countResp := resp.(*protobuf.CountResponse)
if countResp.GetErr() != nil {
err = errors.New(countResp.GetErr().GetError())
return 0, err
}
return countResp.GetCount(), nil
}
// Range scan index between low and high.
func (c *GsiScanClient) Range(
defnID uint64, low, high common.SecondaryKey, inclusion Inclusion,
distinct bool, limit int64, cons common.Consistency, vector *TsConsistency,
callb ResponseHandler) (error, bool) {
// serialize low and high values.
l, err := json.Marshal(low)
if err != nil {
return err, false
}
h, err := json.Marshal(high)
if err != nil {
return err, false
}
connectn, err := c.pool.Get()
if err != nil {
return err, false
}
healthy := true
defer func() { c.pool.Return(connectn, healthy) }()
conn, pkt := connectn.conn, connectn.pkt
req := &protobuf.ScanRequest{
DefnID: proto.Uint64(defnID),
Span: &protobuf.Span{
Range: &protobuf.Range{
Low: l, High: h, Inclusion: proto.Uint32(uint32(inclusion)),
},
},
Distinct: proto.Bool(distinct),
Limit: proto.Int64(limit),
Cons: proto.Uint32(uint32(cons)),
}
if vector != nil {
req.Vector = protobuf.NewTsConsistency(
vector.Vbnos, vector.Seqnos, vector.Vbuuids, vector.Crc64)
}
// ---> protobuf.ScanRequest
if err := c.sendRequest(conn, pkt, req); err != nil {
fmsg := "%v Range() request transport failed `%v`\n"
logging.Errorf(fmsg, c.logPrefix, err)
healthy = false
return err, false
}
cont, partial := true, false
for cont {
// <--- protobuf.ResponseStream
cont, healthy, err = c.streamResponse(conn, pkt, callb)
if err != nil { // if err, cont should have been set to false
fmsg := "%v Range() response failed `%v`\n"
logging.Errorf(fmsg, c.logPrefix, err)
} else { // partial succeeded
partial = true
}
}
return err, partial
}
// Lookup scan index between low and high.
func (c *GsiScanClient) Lookup(
defnID uint64, values []common.SecondaryKey,
distinct bool, limit int64,
cons common.Consistency, vector *TsConsistency,
callb ResponseHandler) (error, bool) {
// serialize lookup value.
equals := make([][]byte, 0, len(values))
for _, value := range values {
val, err := json.Marshal(value)
if err != nil {
return err, false
}
equals = append(equals, val)
}
connectn, err := c.pool.Get()
if err != nil {
return err, false
}
healthy := true
defer func() { c.pool.Return(connectn, healthy) }()
conn, pkt := connectn.conn, connectn.pkt
req := &protobuf.ScanRequest{
DefnID: proto.Uint64(defnID),
Span: &protobuf.Span{Equals: equals},
Distinct: proto.Bool(distinct),
Limit: proto.Int64(limit),
Cons: proto.Uint32(uint32(cons)),
}
if vector != nil {
req.Vector = protobuf.NewTsConsistency(
vector.Vbnos, vector.Seqnos, vector.Vbuuids, vector.Crc64)
}
// ---> protobuf.ScanRequest
if err := c.sendRequest(conn, pkt, req); err != nil {
fmsg := "%v Lookup() request transport failed `%v`\n"
logging.Errorf(fmsg, c.logPrefix, err)
healthy = false
return err, false
}
cont, partial := true, false
for cont {
// <--- protobuf.ResponseStream
cont, healthy, err = c.streamResponse(conn, pkt, callb)
if err != nil { // if err, cont should have been set to false
fmsg := "%v Lookup() response failed `%v`\n"
logging.Errorf(fmsg, c.logPrefix, err)
} else { // partially succeeded
partial = true
}
}
return err, partial
}
// ScanAll for full table scan.
func (c *GsiScanClient) ScanAll(
defnID uint64, limit int64,
cons common.Consistency, vector *TsConsistency,
callb ResponseHandler) (error, bool) {
connectn, err := c.pool.Get()
if err != nil {
return err, false
}
healthy := true
defer func() { c.pool.Return(connectn, healthy) }()
conn, pkt := connectn.conn, connectn.pkt
req := &protobuf.ScanAllRequest{
DefnID: proto.Uint64(defnID),
Limit: proto.Int64(limit),
Cons: proto.Uint32(uint32(cons)),
}
if vector != nil {
req.Vector = protobuf.NewTsConsistency(
vector.Vbnos, vector.Seqnos, vector.Vbuuids, vector.Crc64)
}
if err := c.sendRequest(conn, pkt, req); err != nil {
fmsg := "%v ScanAll() request transport failed `%v`\n"
logging.Errorf(fmsg, c.logPrefix, err)
healthy = false
return err, false
}
cont, partial := true, false
for cont {
// <--- protobuf.ResponseStream
cont, healthy, err = c.streamResponse(conn, pkt, callb)
if err != nil { // if err, cont should have been set to false
fmsg := "%v ScanAll() response failed `%v`\n"
logging.Errorf(fmsg, c.logPrefix, err)
} else {
partial = true
}
}
return err, partial
}
// CountRange to count number entries in the given range.
func (c *GsiScanClient) CountRange(
defnID uint64, low, high common.SecondaryKey, inclusion Inclusion,
cons common.Consistency, vector *TsConsistency) (int64, error) {
// serialize low and high values.
l, err := json.Marshal(low)
if err != nil {
return 0, err
}
h, err := json.Marshal(high)
if err != nil {
return 0, err
}
req := &protobuf.CountRequest{
DefnID: proto.Uint64(defnID),
Span: &protobuf.Span{
Range: &protobuf.Range{
Low: l, High: h, Inclusion: proto.Uint32(uint32(inclusion)),
},
},
Cons: proto.Uint32(uint32(cons)),
}
if vector != nil {
req.Vector = protobuf.NewTsConsistency(
vector.Vbnos, vector.Seqnos, vector.Vbuuids, vector.Crc64)
}
resp, err := c.doRequestResponse(req)
if err != nil {
return 0, err
}
countResp := resp.(*protobuf.CountResponse)
if countResp.GetErr() != nil {
err = errors.New(countResp.GetErr().GetError())
return 0, err
}
return countResp.GetCount(), nil
}