// extractKVRanges extracts kv.KeyRanges slice from ctx.keyRanges, and also returns if it is in descending order. func (rs *localRegion) extractKVRanges(ctx *selectContext) (kvRanges []kv.KeyRange, desc bool) { sel := ctx.sel for _, kran := range ctx.keyRanges { upperKey := kran.EndKey if bytes.Compare(upperKey, rs.startKey) <= 0 { continue } lowerKey := kran.StartKey if bytes.Compare(lowerKey, rs.endKey) >= 0 { break } var kvr kv.KeyRange if bytes.Compare(lowerKey, rs.startKey) <= 0 { kvr.StartKey = rs.startKey } else { kvr.StartKey = lowerKey } if bytes.Compare(upperKey, rs.endKey) <= 0 { kvr.EndKey = upperKey } else { kvr.EndKey = rs.endKey } kvRanges = append(kvRanges, kvr) } if sel.OrderBy != nil { desc = sel.OrderBy[0].Desc } if desc { reverseKVRanges(kvRanges) } return }
// extractKVRanges extracts kv.KeyRanges slice from ctx.keyRanges, and also returns if it is in descending order. func (rs *localRegion) extractKVRanges(ctx *selectContext) (kvRanges []kv.KeyRange) { for _, kran := range ctx.keyRanges { upperKey := kran.EndKey if bytes.Compare(upperKey, rs.startKey) <= 0 { continue } lowerKey := kran.StartKey if bytes.Compare(lowerKey, rs.endKey) >= 0 { break } var kvr kv.KeyRange if bytes.Compare(lowerKey, rs.startKey) <= 0 { kvr.StartKey = rs.startKey } else { kvr.StartKey = lowerKey } if bytes.Compare(upperKey, rs.endKey) <= 0 { kvr.EndKey = upperKey } else { kvr.EndKey = rs.endKey } kvRanges = append(kvRanges, kvr) } if ctx.descScan { reverseKVRanges(kvRanges) } return }
// extractKVRanges extracts kv.KeyRanges slice from a SelectRequest, and also returns if it is in descending order. func (rs *localRegion) extractKVRanges(sel *tipb.SelectRequest) (kvRanges []kv.KeyRange, desc bool) { var ( tid int64 idxID int64 ) if sel.IndexInfo != nil { tid = sel.IndexInfo.GetTableId() idxID = sel.IndexInfo.GetIndexId() } else { tid = sel.TableInfo.GetTableId() } for _, kran := range sel.Ranges { var upperKey, lowerKey kv.Key if idxID == 0 { upperKey = tablecodec.EncodeRowKey(tid, kran.GetHigh()) if bytes.Compare(upperKey, rs.startKey) <= 0 { continue } lowerKey = tablecodec.EncodeRowKey(tid, kran.GetLow()) } else { upperKey = tablecodec.EncodeIndexSeekKey(tid, idxID, kran.GetHigh()) if bytes.Compare(upperKey, rs.startKey) <= 0 { continue } lowerKey = tablecodec.EncodeIndexSeekKey(tid, idxID, kran.GetLow()) } if bytes.Compare(lowerKey, rs.endKey) >= 0 { break } var kvr kv.KeyRange if bytes.Compare(lowerKey, rs.startKey) <= 0 { kvr.StartKey = rs.startKey } else { kvr.StartKey = lowerKey } if bytes.Compare(upperKey, rs.endKey) <= 0 { kvr.EndKey = upperKey } else { kvr.EndKey = rs.endKey } kvRanges = append(kvRanges, kvr) } if sel.OrderBy != nil { desc = *sel.OrderBy[0].Desc } if desc { reverseKVRanges(kvRanges) } return }
// extractKVRanges extracts kv.KeyRanges slice from a SelectRequest, and also returns if it is in descending order. func (h *rpcHandler) extractKVRanges(sel *tipb.SelectRequest) (kvRanges []kv.KeyRange, desc bool) { var ( tid int64 idxID int64 ) if sel.IndexInfo != nil { tid = sel.IndexInfo.GetTableId() idxID = sel.IndexInfo.GetIndexId() } else { tid = sel.TableInfo.GetTableId() } for _, kran := range sel.Ranges { var upperKey, lowerKey kv.Key if idxID == 0 { upperKey = tablecodec.EncodeRowKey(tid, kran.GetHigh()) if bytes.Compare(upperKey, h.startKey) <= 0 { continue } lowerKey = tablecodec.EncodeRowKey(tid, kran.GetLow()) } else { upperKey = tablecodec.EncodeIndexSeekKey(tid, idxID, kran.GetHigh()) if bytes.Compare(upperKey, h.startKey) <= 0 { continue } lowerKey = tablecodec.EncodeIndexSeekKey(tid, idxID, kran.GetLow()) } if len(h.endKey) != 0 && bytes.Compare([]byte(lowerKey), h.endKey) >= 0 { break } var kvr kv.KeyRange kvr.StartKey = kv.Key(maxStartKey(lowerKey, h.startKey)) kvr.EndKey = kv.Key(minEndKey(upperKey, h.endKey)) kvRanges = append(kvRanges, kvr) } if sel.OrderBy != nil { desc = *sel.OrderBy[0].Desc } if desc { reverseKVRanges(kvRanges) } return }
// extractKVRanges extracts kv.KeyRanges slice from a SelectRequest, and also returns if it is in descending order. func (h *rpcHandler) extractKVRanges(ctx *selectContext) (kvRanges []kv.KeyRange, desc bool) { sel := ctx.sel for _, kran := range ctx.keyRanges { upperKey := kran.GetEnd() if bytes.Compare(upperKey, h.startKey) <= 0 { continue } lowerKey := kran.GetStart() if len(h.endKey) != 0 && bytes.Compare([]byte(lowerKey), h.endKey) >= 0 { break } var kvr kv.KeyRange kvr.StartKey = kv.Key(maxStartKey(lowerKey, h.startKey)) kvr.EndKey = kv.Key(minEndKey(upperKey, h.endKey)) kvRanges = append(kvRanges, kvr) } if sel.OrderBy != nil { desc = sel.OrderBy[0].Desc } if desc { reverseKVRanges(kvRanges) } return }
func (rs *localRegion) getRowsFromRange(ctx *selectContext, ran kv.KeyRange, limit int64, desc bool) (count int64, err error) { if limit == 0 { return 0, nil } if ran.IsPoint() { var value []byte value, err = ctx.txn.Get(ran.StartKey) if terror.ErrorEqual(err, kv.ErrNotExist) { return 0, nil } else if err != nil { return 0, errors.Trace(err) } var h int64 h, err = tablecodec.DecodeRowKey(ran.StartKey) if err != nil { return 0, errors.Trace(err) } gotRow, err1 := rs.handleRowData(ctx, h, value) if err1 != nil { return 0, errors.Trace(err1) } if gotRow { count++ } return } var seekKey kv.Key if desc { seekKey = ran.EndKey } else { seekKey = ran.StartKey } for { if limit == 0 { break } var ( it kv.Iterator err error ) if desc { it, err = ctx.txn.SeekReverse(seekKey) } else { it, err = ctx.txn.Seek(seekKey) } if err != nil { return 0, errors.Trace(err) } if !it.Valid() { break } if desc { if it.Key().Cmp(ran.StartKey) < 0 { break } seekKey = tablecodec.TruncateToRowKeyLen(it.Key()) } else { if it.Key().Cmp(ran.EndKey) >= 0 { break } seekKey = it.Key().PrefixNext() } h, err := tablecodec.DecodeRowKey(it.Key()) if err != nil { return 0, errors.Trace(err) } gotRow, err := rs.handleRowData(ctx, h, it.Value()) if err != nil { return 0, errors.Trace(err) } if gotRow { limit-- count++ } } return count, nil }
func (h *rpcHandler) getRowsFromRange(ctx *selectContext, ran kv.KeyRange, limit int64, desc bool) ([]*tipb.Row, error) { startKey := maxStartKey(ran.StartKey, h.startKey) endKey := minEndKey(ran.EndKey, h.endKey) if limit == 0 || bytes.Compare(startKey, endKey) >= 0 { return nil, nil } var rows []*tipb.Row if ran.IsPoint() { val, err := h.mvccStore.Get(startKey, ctx.sel.GetStartTs()) if len(val) == 0 { return nil, nil } else if err != nil { return nil, errors.Trace(err) } handle, err := tablecodec.DecodeRowKey(kv.Key(startKey)) if err != nil { return nil, errors.Trace(err) } row, err := h.handleRowData(ctx, handle, val) if err != nil { return nil, errors.Trace(err) } if row != nil { rows = append(rows, row) } return rows, nil } var seekKey []byte if desc { seekKey = endKey } else { seekKey = startKey } for { if limit == 0 { break } var ( pairs []Pair pair Pair err error ) if desc { pairs = h.mvccStore.ReverseScan(startKey, seekKey, 1, ctx.sel.GetStartTs()) } else { pairs = h.mvccStore.Scan(seekKey, endKey, 1, ctx.sel.GetStartTs()) } if len(pairs) > 0 { pair = pairs[0] } if pair.Err != nil { // TODO: handle lock error. return nil, errors.Trace(pair.Err) } if pair.Key == nil { break } if desc { if bytes.Compare(pair.Key, startKey) < 0 { break } seekKey = []byte(tablecodec.TruncateToRowKeyLen(kv.Key(pair.Key))) } else { if bytes.Compare(pair.Key, endKey) >= 0 { break } seekKey = []byte(kv.Key(pair.Key).PrefixNext()) } handle, err := tablecodec.DecodeRowKey(pair.Key) if err != nil { return nil, errors.Trace(err) } row, err := h.handleRowData(ctx, handle, pair.Value) if err != nil { return nil, errors.Trace(err) } if row != nil { rows = append(rows, row) limit-- } } return rows, nil }
func (rs *localRegion) getRowsFromRange(ctx *selectContext, ran kv.KeyRange, limit int64, desc bool) ([]*tipb.Row, error) { if limit == 0 { return nil, nil } var rows []*tipb.Row if ran.IsPoint() { _, err := ctx.txn.Get(ran.StartKey) if terror.ErrorEqual(err, kv.ErrNotExist) { return nil, nil } else if err != nil { return nil, errors.Trace(err) } h, err := tablecodec.DecodeRowKey(ran.StartKey) if err != nil { return nil, errors.Trace(err) } match, err := rs.evalWhereForRow(ctx, h) if err != nil { return nil, errors.Trace(err) } if !match { return nil, nil } row, err := rs.getRowByHandle(ctx, h) if err != nil { return nil, errors.Trace(err) } if row != nil { rows = append(rows, row) } return rows, nil } var seekKey kv.Key if desc { seekKey = ran.EndKey } else { seekKey = ran.StartKey } for { if limit == 0 { break } var ( it kv.Iterator err error ) if desc { it, err = ctx.txn.SeekReverse(seekKey) } else { it, err = ctx.txn.Seek(seekKey) } if err != nil { return nil, errors.Trace(err) } if !it.Valid() { break } if desc { if it.Key().Cmp(ran.StartKey) < 0 { break } seekKey = tablecodec.TruncateToRowKeyLen(it.Key()) } else { if it.Key().Cmp(ran.EndKey) >= 0 { break } seekKey = it.Key().PrefixNext() } h, err := tablecodec.DecodeRowKey(it.Key()) if err != nil { return nil, errors.Trace(err) } match, err := rs.evalWhereForRow(ctx, h) if err != nil { return nil, errors.Trace(err) } if !match { continue } row, err := rs.getRowByHandle(ctx, h) if err != nil { return nil, errors.Trace(err) } if row != nil { rows = append(rows, row) limit-- } } return rows, nil }