// Scan retrieves the values specified in families from the given range.
func (c *Client) Scan(s *hrpc.Scan) ([]*pb.Result, error) {
var results []*pb.Result
var scanres *pb.ScanResponse
var rpc *hrpc.Scan
ctx := s.GetContext()
table := s.Table()
families := s.GetFamilies()
filters := s.GetFilter()
startRow := s.GetStartRow()
stopRow := s.GetStopRow()
for {
// Make a new Scan RPC for this region
if rpc == nil {
// If it's the first region, just begin at the given startRow
rpc, _ = hrpc.NewScanRange(ctx, table, startRow, stopRow, hrpc.Families(families), hrpc.Filters(filters))
} else {
// If it's not the first region, we want to start at whatever the
// last region's StopKey was
rpc, _ = hrpc.NewScanRange(ctx, table, rpc.GetRegionStop(), stopRow, hrpc.Families(families), hrpc.Filters(filters))
}
res, err := c.sendRPC(rpc)
if err != nil {
return nil, err
}
scanres = res.(*pb.ScanResponse)
results = append(results, scanres.Results...)
// TODO: The more_results field of the ScanResponse object was always
// true, so we should figure out if there's a better way to know when
// to move on to the next region than making an extra request and
// seeing if there were no results
for len(scanres.Results) != 0 {
rpc = hrpc.NewScanFromID(ctx, table, *scanres.ScannerId, rpc.Key())
res, err = c.sendRPC(rpc)
if err != nil {
return nil, err
}
scanres = res.(*pb.ScanResponse)
results = append(results, scanres.Results...)
}
rpc = hrpc.NewCloseFromID(ctx, table, *scanres.ScannerId, rpc.Key())
if err != nil {
return nil, err
}
res, err = c.sendRPC(rpc)
// Check to see if this region is the last we should scan (either
// because (1) it's the last region or (3) because its stop_key is
// greater than or equal to the stop_key of this scanner provided
// that (2) we're not trying to scan until the end of the table).
// (1) (2) (3)
if len(rpc.GetRegionStop()) == 0 || (len(stopRow) != 0 && bytes.Compare(stopRow, rpc.GetRegionStop()) <= 0) {
return results, nil
}
}
}
func TestGetTimeRangeVersions(t *testing.T) {
key := "TestGetTimeRangeVersions"
c := gohbase.NewClient(*host)
err := insertKeyValue(c, key, "cf", []byte("1"), hrpc.Timestamp(time.Unix(0, 50*1e6)))
if err != nil {
t.Fatalf("Put failed: %s", err)
}
err = insertKeyValue(c, key, "cf", []byte("1"), hrpc.Timestamp(time.Unix(0, 51*1e6)))
if err != nil {
t.Fatalf("Put failed: %s", err)
}
err = insertKeyValue(c, key, "cf", []byte("1"), hrpc.Timestamp(time.Unix(0, 49*1e6)))
if err != nil {
t.Fatalf("Put failed: %s", err)
}
var maxVersions uint32 = 2
get, err := hrpc.NewGetStr(context.Background(), table, key,
hrpc.Families(map[string][]string{"cf": nil}), hrpc.TimeRange(time.Unix(0, 0),
time.Unix(0, 51*1e6)), hrpc.MaxVersions(maxVersions))
rsp, err := c.Get(get)
if err != nil {
t.Fatalf("Get failed: %s", err)
}
if uint32(len(rsp.Cells)) != maxVersions {
t.Fatalf("Expected versions: %d, Got versions: %d", maxVersions, len(rsp.Cells))
}
getTs1 := *rsp.Cells[0].Timestamp
if getTs1 != 50 {
t.Errorf("Timestamps are not the same. Expected Time: %v, Got Time: %v",
50, getTs1)
}
getTs2 := *rsp.Cells[1].Timestamp
if getTs2 != 49 {
t.Errorf("Timestamps are not the same. Expected Time: %v, Got Time: %v",
49, getTs2)
}
// get with no versions set
get, err = hrpc.NewGetStr(context.Background(), table, key,
hrpc.Families(map[string][]string{"cf": nil}), hrpc.TimeRange(time.Unix(0, 0),
time.Unix(0, 51*1e6)))
rsp, err = c.Get(get)
if err != nil {
t.Fatalf("Get failed: %s", err)
}
if uint32(len(rsp.Cells)) != 1 {
t.Fatalf("Expected versions: %d, Got versions: %d", 1, len(rsp.Cells))
}
getTs1 = *rsp.Cells[0].Timestamp
if getTs1 != 50 {
t.Errorf("Timestamps are not the same. Expected Time: %v, Got Time: %v",
50, getTs1)
}
}
func TestMultiplePutsGetsSequentially(t *testing.T) {
const num_ops = 100
keyPrefix := "row3"
headers := map[string][]string{"cf": nil}
c := gohbase.NewClient(*host)
err := performNPuts(keyPrefix, num_ops)
if err != nil {
t.Errorf("Put returned an error: %v", err)
}
for i := num_ops - 1; i >= 0; i-- {
key := keyPrefix + fmt.Sprintf("%d", i)
get, err := hrpc.NewGetStr(context.Background(), table, key, hrpc.Families(headers))
rsp, err := c.Get(get)
if err != nil {
t.Errorf("Get returned an error: %v", err)
}
if len(rsp.Result.Cell) != 1 {
t.Errorf("Incorrect number of cells returned by Get: %d", len(rsp.Result.Cell))
}
rsp_value := rsp.Result.Cell[0].GetValue()
if !bytes.Equal(rsp_value, []byte(fmt.Sprintf("%d", i))) {
t.Errorf("Get returned an incorrect result. Expected: %v, Got: %v",
[]byte(fmt.Sprintf("%d", i)), rsp_value)
}
}
}
func TestPutMultipleCells(t *testing.T) {
key := "row2.5"
values := map[string]map[string][]byte{"cf": map[string][]byte{}, "cf2": map[string][]byte{}}
values["cf"]["a"] = []byte("a")
values["cf"]["b"] = []byte("b")
values["cf2"]["a"] = []byte("a")
c := gohbase.NewClient(*host)
putRequest, err := hrpc.NewPutStr(context.Background(), table, key, values)
_, err = c.Put(putRequest)
if err != nil {
t.Errorf("Put returned an error: %v", err)
}
families := map[string][]string{"cf": nil, "cf2": nil}
get, err := hrpc.NewGetStr(context.Background(), table, key, hrpc.Families(families))
rsp, err := c.Get(get)
if err != nil {
t.Errorf("Get returned an error: %v", err)
}
cells := rsp.GetResult().Cell
if len(cells) != 3 {
t.Errorf("Get expected 3 cells. Received: %d", len(cells))
}
for _, cell := range cells {
if !bytes.Equal(cell.GetQualifier(), cell.GetValue()) {
t.Errorf("Get returned an incorrect result. Expected: %v, Received: %v",
cell.GetQualifier(), cell.GetValue())
}
}
}
func TestDeleteTimestamp(t *testing.T) {
key := "TestDeleteTimestamp"
c := gohbase.NewClient(*host)
var putTs uint64 = 50
timestamp := time.Unix(0, int64(putTs*1e6))
err := insertKeyValue(c, key, "cf", []byte("1"), hrpc.Timestamp(timestamp))
if err != nil {
t.Fatalf("Put failed: %s", err)
}
deleteRequest, err := hrpc.NewDelStr(context.Background(), table, key,
map[string]map[string][]byte{"cf": map[string][]byte{"a": nil}},
hrpc.Timestamp(timestamp))
_, err = c.Delete(deleteRequest)
if err != nil {
t.Fatalf("Delete failed: %s", err)
}
get, err := hrpc.NewGetStr(context.Background(), table, key,
hrpc.Families(map[string][]string{"cf": nil}))
rsp, err := c.Get(get)
if err != nil {
t.Fatalf("Get failed: %s", err)
}
if len(rsp.Cells) != 0 {
t.Errorf("Timestamp wasn't deleted, get result length: %d", len(rsp.Cells))
}
}
// Note: This function currently causes an infinite loop in the client throwing the error -
// 2015/06/19 14:34:11 Encountered an error while reading: Failed to read from the RS: EOF
func TestChangingRegionServers(t *testing.T) {
key := "row8"
val := []byte("1")
headers := map[string][]string{"cf": nil}
if host == nil {
t.Fatal("Host is not set!")
}
c := gohbase.NewClient(*host)
err := insertKeyValue(c, key, "cf", val)
if err != nil {
t.Errorf("Put returned an error: %v", err)
}
// RegionServer 1 hosts all the current regions.
// Now launch servers 2,3
test.LaunchRegionServers([]string{"2", "3"})
// Now (gracefully) stop servers 1,2.
// All regions should now be on server 3.
test.StopRegionServers([]string{"1", "2"})
get, err := hrpc.NewGetStr(context.Background(), table, key, hrpc.Families(headers))
rsp, err := c.Get(get)
if err != nil {
t.Errorf("Get returned an error: %v", err)
}
rsp_value := rsp.Result.Cell[0].GetValue()
if !bytes.Equal(rsp_value, val) {
t.Errorf("Get returned an incorrect result. Expected: %v, Received: %v",
val, rsp_value)
}
// Clean up by re-launching RS1 and closing RS3
test.LaunchRegionServers([]string{"1"})
test.StopRegionServers([]string{"3"})
}
func TestGetMultipleCells(t *testing.T) {
key := "row1.75"
c := gohbase.NewClient(*host, gohbase.FlushInterval(time.Millisecond*2))
err := insertKeyValue(c, key, "cf", []byte("cf"))
if err != nil {
t.Errorf("Put returned an error: %v", err)
}
err = insertKeyValue(c, key, "cf2", []byte("cf2"))
if err != nil {
t.Errorf("Put returned an error: %v", err)
}
families := map[string][]string{"cf": nil, "cf2": nil}
get, err := hrpc.NewGetStr(context.Background(), table, key, hrpc.Families(families))
rsp, err := c.Get(get)
cells := rsp.GetResult().Cell
num_results := len(cells)
if num_results != 2 {
t.Errorf("Get expected 2 cells. Received: %d", num_results)
}
for _, cell := range cells {
if !bytes.Equal(cell.GetFamily(), cell.GetValue()) {
t.Errorf("Get returned an incorrect result. Expected: %v, Received: %v",
cell.GetFamily(), cell.GetValue())
}
}
}
func TestGet(t *testing.T) {
key := "row1"
val := []byte("1")
headers := map[string][]string{"cf": nil}
if host == nil {
t.Fatal("Host is not set!")
}
c := gohbase.NewClient(*host)
err := insertKeyValue(c, key, "cf", val)
if err != nil {
t.Errorf("Put returned an error: %v", err)
}
get, err := hrpc.NewGetStr(context.Background(), table, key, hrpc.Families(headers))
if err != nil {
t.Fatalf("Failed to create Get request: %s", err)
}
rsp, err := c.Get(get)
if err != nil {
t.Errorf("Get returned an error: %v", err)
}
rsp_value := rsp.Result.Cell[0].GetValue()
if !bytes.Equal(rsp_value, val) {
t.Errorf("Get returned an incorrect result. Expected: %v, Got: %v",
val, rsp_value)
}
get.ExistsOnly()
rsp, err = c.Get(get)
if err != nil {
t.Errorf("Get returned an error: %v", err)
} else if !*rsp.Result.Exists {
t.Error("Get claimed that our row didn't exist")
}
ctx, _ := context.WithTimeout(context.Background(), 0)
get, err = hrpc.NewGetStr(ctx, table, key, hrpc.Families(headers))
if err != nil {
t.Fatalf("Failed to create Get request: %s", err)
}
_, err = c.Get(get)
if err != gohbase.ErrDeadline {
t.Errorf("Get ignored the deadline")
}
}
func TestTimeRangeError(t *testing.T) {
key := "TestTimeRangeError"
table := "test"
_, err := hrpc.NewGetStr(context.Background(), table, key,
hrpc.Families(map[string][]string{"cf": nil}), hrpc.TimeRange(time.Unix(51, 0),
time.Unix(51, 0)))
expErr := "'from' timestamp (51000ms) is greater or equal to 'to' timestamp (51000ms)"
if err.Error() != expErr {
t.Errorf("Expected error: %s, Got error: %s", expErr, err)
}
_, err = hrpc.NewGetStr(context.Background(), table, key,
hrpc.Families(map[string][]string{"cf": nil}), hrpc.TimeRange(time.Unix(52, 0),
time.Unix(51, 0)))
expErr = "'from' timestamp (52000ms) is greater or equal to 'to' timestamp (51000ms)"
if err.Error() != expErr {
t.Errorf("Expected error: %s, Got error: %s", expErr, err)
}
}
func TestNewScan(t *testing.T) {
ctx := context.Background()
table := "test"
tableb := []byte(table)
fam := make(map[string][]string)
fam["info"] = []string{"c1"}
filter1 := filter.NewFirstKeyOnlyFilter()
start := "0"
stop := "100"
startb := []byte("0")
stopb := []byte("100")
scan, err := hrpc.NewScan(ctx, tableb)
if err != nil || !confirmScanAttributes(scan, ctx, tableb, nil, nil, nil, nil) {
t.Errorf("Scan1 didn't set attributes correctly.")
}
scan, err = hrpc.NewScanRange(ctx, tableb, startb, stopb)
if err != nil || !confirmScanAttributes(scan, ctx, tableb, startb, stopb, nil, nil) {
t.Errorf("Scan2 didn't set attributes correctly.")
}
scan, err = hrpc.NewScanStr(ctx, table)
if err != nil || !confirmScanAttributes(scan, ctx, tableb, nil, nil, nil, nil) {
t.Errorf("Scan3 didn't set attributes correctly.")
}
scan, err = hrpc.NewScanRangeStr(ctx, table, start, stop)
if err != nil || !confirmScanAttributes(scan, ctx, tableb, startb, stopb, nil, nil) {
t.Errorf("Scan4 didn't set attributes correctly.")
}
scan, err = hrpc.NewScanRange(ctx, tableb, startb, stopb, hrpc.Families(fam),
hrpc.Filters(filter1))
if err != nil || !confirmScanAttributes(scan, ctx, tableb, startb, stopb, fam, filter1) {
t.Errorf("Scan5 didn't set attributes correctly.")
}
scan, err = hrpc.NewScan(ctx, tableb, hrpc.Filters(filter1), hrpc.Families(fam))
if err != nil || !confirmScanAttributes(scan, ctx, tableb, nil, nil, fam, filter1) {
t.Errorf("Scan6 didn't set attributes correctly.")
}
}
func TestNewGet(t *testing.T) {
ctx := context.Background()
table := "test"
tableb := []byte(table)
key := "45"
keyb := []byte(key)
fam := make(map[string][]string)
fam["info"] = []string{"c1"}
filter1 := filter.NewFirstKeyOnlyFilter()
get, err := hrpc.NewGet(ctx, tableb, keyb)
if err != nil || !confirmGetAttributes(get, ctx, tableb, keyb, nil, nil) {
t.Errorf("Get1 didn't set attributes correctly.")
}
get, err = hrpc.NewGetStr(ctx, table, key)
if err != nil || !confirmGetAttributes(get, ctx, tableb, keyb, nil, nil) {
t.Errorf("Get2 didn't set attributes correctly.")
}
get, err = hrpc.NewGet(ctx, tableb, keyb, hrpc.Families(fam))
if err != nil || !confirmGetAttributes(get, ctx, tableb, keyb, fam, nil) {
t.Errorf("Get3 didn't set attributes correctly.")
}
get, err = hrpc.NewGet(ctx, tableb, keyb, hrpc.Filters(filter1))
if err != nil || !confirmGetAttributes(get, ctx, tableb, keyb, nil, filter1) {
t.Errorf("Get4 didn't set attributes correctly.")
}
get, err = hrpc.NewGet(ctx, tableb, keyb, hrpc.Filters(filter1), hrpc.Families(fam))
if err != nil || !confirmGetAttributes(get, ctx, tableb, keyb, fam, filter1) {
t.Errorf("Get5 didn't set attributes correctly.")
}
get, err = hrpc.NewGet(ctx, tableb, keyb, hrpc.Filters(filter1))
err = hrpc.Families(fam)(get)
if err != nil || !confirmGetAttributes(get, ctx, tableb, keyb, fam, filter1) {
t.Errorf("Get6 didn't set attributes correctly.")
}
}
func BenchmarkGet(b *testing.B) {
b.ReportAllocs()
keyPrefix := "row10"
err := performNPuts(keyPrefix, b.N)
if err != nil {
b.Errorf("Put returned an error: %v", err)
}
c := gohbase.NewClient(*host)
b.ResetTimer()
headers := map[string][]string{"cf": nil}
for i := 0; i < b.N; i++ {
key := keyPrefix + fmt.Sprintf("%d", i)
get, _ := hrpc.NewGetStr(context.Background(), table, key, hrpc.Families(headers))
c.Get(get)
}
}
func TestGetBadColumnFamily(t *testing.T) {
key := "row1.625"
c := gohbase.NewClient(*host)
err := insertKeyValue(c, key, "cf", []byte("Bad!"))
if err != nil {
t.Errorf("Put returned an error: %v", err)
}
families := map[string][]string{"badcf": nil}
get, err := hrpc.NewGetStr(context.Background(), table, key, hrpc.Families(families))
rsp, err := c.Get(get)
if err == nil {
t.Errorf("Get didn't return an error! (It should have)")
}
if rsp.GetResult() != nil {
t.Errorf("Get expected no result. Received: %v", rsp.GetResult())
}
}
// Locates the region in which the given row key for the given table is.
func (c *Client) locateRegion(ctx context.Context,
table, key []byte) (*regioninfo.Info, string, uint16, error) {
metaKey := createRegionSearchKey(table, key)
rpc, err := hrpc.NewGetBefore(ctx, metaTableName, metaKey, hrpc.Families(infoFamily))
if err != nil {
return nil, "", 0, err
}
rpc.SetRegion(c.metaRegionInfo)
resp, err := c.sendRPC(rpc)
if err != nil {
ch := c.metaRegionInfo.GetAvailabilityChan()
if ch != nil {
select {
case <-ch:
return c.locateRegion(ctx, table, key)
case <-rpc.GetContext().Done():
return nil, "", 0, ErrDeadline
}
} else {
return nil, "", 0, err
}
}
metaRow := resp.(*pb.GetResponse)
if metaRow.Result == nil {
return nil, "", 0, TableNotFound
}
reg, host, port, err := c.parseMetaTableResponse(metaRow)
if err != nil {
return nil, "", 0, err
}
if !bytes.Equal(table, reg.Table) {
// This would indicate a bug in HBase.
return nil, "", 0, fmt.Errorf("WTF: Meta returned an entry for the wrong table!"+
" Looked up table=%q key=%q got region=%s", table, key, reg)
} else if len(reg.StopKey) != 0 &&
bytes.Compare(key, reg.StopKey) >= 0 {
// This would indicate a hole in the meta table.
return nil, "", 0, fmt.Errorf("WTF: Meta returned an entry for the wrong region!"+
" Looked up table=%q key=%q got region=%s", table, key, reg)
}
return reg, host, port, nil
}
func TestGetDoesntExist(t *testing.T) {
key := "row1.5"
c := gohbase.NewClient(*host)
headers := map[string][]string{"cf": nil}
get, err := hrpc.NewGetStr(context.Background(), table, key, hrpc.Families(headers))
rsp, err := c.Get(get)
if err != nil {
t.Errorf("Get returned an error: %v", err)
} else if results := len(rsp.GetResult().Cell); results != 0 {
t.Errorf("Get expected 0 cells. Received: %d", results)
}
get.ExistsOnly()
rsp, err = c.Get(get)
if err != nil {
t.Errorf("Get returned an error: %v", err)
} else if *rsp.Result.Exists {
t.Error("Get claimed that our non-existent row exists")
}
}
func TestPutTimestamp(t *testing.T) {
key := "TestPutTimestamp"
c := gohbase.NewClient(*host)
var putTs uint64 = 50
timestamp := time.Unix(0, int64(putTs*1e6))
err := insertKeyValue(c, key, "cf", []byte("1"), hrpc.Timestamp(timestamp))
if err != nil {
t.Fatalf("Put failed: %s", err)
}
get, err := hrpc.NewGetStr(context.Background(), table, key,
hrpc.Families(map[string][]string{"cf": nil}))
rsp, err := c.Get(get)
if err != nil {
t.Fatalf("Get failed: %s", err)
}
getTs := *rsp.Cells[0].Timestamp
if getTs != putTs {
t.Errorf("Timestamps are not the same. Put Time: %v, Get Time: %v",
putTs, getTs)
}
}
func TestAppend(t *testing.T) {
key := "row7"
c := gohbase.NewClient(*host)
// Inserting "Hello"
insertErr := insertKeyValue(c, key, "cf", []byte("Hello"))
if insertErr != nil {
t.Errorf("Put returned an error: %v", insertErr)
}
// Appending " my name is Dog."
values := map[string]map[string][]byte{"cf": map[string][]byte{}}
values["cf"]["a"] = []byte(" my name is Dog.")
appRequest, err := hrpc.NewAppStr(context.Background(), table, key, values)
appRsp, err := c.Append(appRequest)
if err != nil {
t.Errorf("Append returned an error: %v", err)
}
if appRsp.GetResult() == nil {
t.Errorf("Append doesn't return updated value.")
}
// Verifying new result is "Hello my name is Dog."
result := appRsp.GetResult().Cell[0].GetValue()
if !bytes.Equal([]byte("Hello my name is Dog."), result) {
t.Errorf("Append returned an incorrect result. Expected: %v, Receieved: %v",
[]byte("Hello my name is Dog."), result)
}
// Make sure the change was actually committed.
headers := map[string][]string{"cf": nil}
get, err := hrpc.NewGetStr(context.Background(), table, key, hrpc.Families(headers))
rsp, err := c.Get(get)
cells := rsp.GetResult().Cell
if len(cells) != 1 {
t.Errorf("Get expected 1 cells. Received: %d", len(cells))
}
result = cells[0].GetValue()
if !bytes.Equal([]byte("Hello my name is Dog."), result) {
t.Errorf("Append returned an incorrect result. Expected: %v, Receieved: %v",
[]byte("Hello my name is Dog."), result)
}
}
func TestTimestampIncreasing(t *testing.T) {
key := "row4"
c := gohbase.NewClient(*host)
var oldTime uint64 = 0
headers := map[string][]string{"cf": nil}
for i := 0; i < 10; i++ {
insertKeyValue(c, key, "cf", []byte("1"))
get, err := hrpc.NewGetStr(context.Background(), table, key, hrpc.Families(headers))
rsp, err := c.Get(get)
if err != nil {
t.Errorf("Get returned an error: %v", err)
break
}
newTime := rsp.GetResult().Cell[0].GetTimestamp()
if newTime <= oldTime {
t.Errorf("Timestamps are not increasing. Old Time: %v, New Time: %v",
oldTime, newTime)
}
oldTime = newTime
time.Sleep(time.Millisecond)
}
}
// Locates the region in which the given row key for the given table is.
func (c *Client) locateRegion(ctx context.Context, table, key []byte) (*region.Client, *regioninfo.Info, error) {
metaKey := createRegionSearchKey(table, key)
rpc, _ := hrpc.NewGetBefore(ctx, metaTableName, metaKey, hrpc.Families(infoFamily))
rpc.SetRegion(c.metaRegionInfo)
resp, err := c.sendRPC(rpc)
if err != nil {
ch := c.metaRegionInfo.GetAvailabilityChan()
if ch != nil {
select {
case <-ch:
return c.locateRegion(ctx, table, key)
case <-rpc.GetContext().Done():
return nil, nil, ErrDeadline
}
} else {
return nil, nil, err
}
}
return c.discoverRegion(ctx, resp.(*pb.GetResponse))
}
func TestMultiplePutsGetsParallel(t *testing.T) {
const num_ops = 1000
keyPrefix := "row3.5"
headers := map[string][]string{"cf": nil}
c := gohbase.NewClient(*host)
// TODO: Currently have to CheckTable before initiating the N requests
// otherwise we face runaway client generation - one for each request.
c.CheckTable(context.Background(), table)
var wg sync.WaitGroup
for i := 0; i < num_ops; i++ {
wg.Add(1)
go func(client *gohbase.Client, key string) {
defer wg.Done()
err := insertKeyValue(client, key, "cf", []byte(key))
if err != nil {
t.Errorf("(Parallel) Put returned an error: %v", err)
}
}(c, keyPrefix+fmt.Sprintf("%d", i))
}
wg.Wait()
// All puts are complete. Now do the same for gets.
for i := num_ops - 1; i >= 0; i-- {
wg.Add(1)
go func(client *gohbase.Client, key string) {
defer wg.Done()
get, err := hrpc.NewGetStr(context.Background(), table, key, hrpc.Families(headers))
rsp, err := c.Get(get)
if err != nil {
t.Errorf("(Parallel) Get returned an error: %v", err)
} else {
rsp_value := rsp.Result.Cell[0].GetValue()
if !bytes.Equal(rsp_value, []byte(key)) {
t.Errorf("Get returned an incorrect result.")
}
}
}(c, keyPrefix+fmt.Sprintf("%d", i))
}
wg.Wait()
}
func TestPutReflection(t *testing.T) {
key := "row2.25"
number := 150
data := struct {
AnInt int `hbase:"cf:a"`
AnInt8 int8 `hbase:"cf:b"`
AnInt16 int16 `hbase:"cf:c"`
AnInt32 int32 `hbase:"cf:d"`
AnInt64 int64 `hbase:"cf:e"`
AnUInt uint `hbase:"cf:f"`
AnUInt8 uint8 `hbase:"cf:g"`
AnUInt16 uint16 `hbase:"cf:h"`
AnUInt32 uint32 `hbase:"cf:i"`
AnUInt64 uint64 `hbase:"cf:j"`
AFloat32 float32 `hbase:"cf:k"`
AFloat64 float64 `hbase:"cf:l"`
AComplex64 complex64 `hbase:"cf:m"`
AComplex128 complex128 `hbase:"cf:n"`
APointer *int `hbase:"cf:o"`
AnArray [6]uint8 `hbase:"cf:p"`
ASlice []uint8 `hbase:"cf:q"`
AString string `hbase:"cf:r"`
}{
AnInt: 10,
AnInt8: 20,
AnInt16: 30,
AnInt32: 40,
AnInt64: 50,
AnUInt: 60,
AnUInt8: 70,
AnUInt16: 80,
AnUInt32: 90,
AnUInt64: 100,
AFloat32: 110,
AFloat64: 120,
AComplex64: 130,
AComplex128: 140,
APointer: &number,
AnArray: [6]uint8{4, 8, 15, 26, 23, 42},
ASlice: []uint8{1, 1, 3, 5, 8, 13, 21, 34, 55},
AString: "This is a test string.",
}
if host == nil {
t.Fatal("Host is not set!")
}
c := gohbase.NewClient(*host)
putRequest, err := hrpc.NewPutStrRef(context.Background(), table, key, data)
if err != nil {
t.Errorf("NewPutStrRef returned an error: %v", err)
}
_, err = c.Put(putRequest)
if err != nil {
t.Errorf("Put returned an error: %v", err)
}
headers := map[string][]string{"cf": nil}
get, err := hrpc.NewGetStr(context.Background(), table, key, hrpc.Families(headers))
if err != nil {
t.Fatalf("Failed to create Get request: %s", err)
}
rsp, err := c.Get(get)
if err != nil {
t.Errorf("Get returned an error: %v", err)
}
expected := map[string][]byte{
"a": []byte{10},
"b": []byte{20},
"c": []byte{30, 0},
"d": []byte{40, 0, 0, 0},
"e": []byte{50, 0, 0, 0, 0, 0, 0, 0},
"f": []byte{60},
"g": []byte{70},
"h": []byte{80, 0},
"i": []byte{90, 0, 0, 0},
"j": []byte{100, 0, 0, 0, 0, 0, 0, 0},
"k": []byte{0, 0, 220, 66},
"l": []byte{0, 0, 0, 0, 0, 0, 94, 64},
"m": []byte{0, 0, 2, 67, 0, 0, 0, 0},
"n": []byte{0, 0, 0, 0, 0, 128, 97, 64, 0, 0, 0, 0, 0, 0, 0, 0},
"o": []byte{150},
"p": []byte{4, 8, 15, 26, 23, 42},
"q": []byte{1, 1, 3, 5, 8, 13, 21, 34, 55},
"r": []byte("This is a test string."),
}
for _, cell := range rsp.Cells {
want, ok := expected[string(cell.Qualifier)]
if !ok {
t.Errorf("Unexpected qualifier: %q in %#v", cell.Qualifier, rsp)
} else if !bytes.Equal(cell.Value, want) {
t.Errorf("qualifier %q didn't match: wanted %q, but got %q",
cell.Qualifier, want, cell.Value)
}
}
}
func TestScanTimeRangeVersions(t *testing.T) {
key := "TestScanTimeRangeVersions"
c := gohbase.NewClient(*host)
err := insertKeyValue(c, key+"1", "cf", []byte("1"), hrpc.Timestamp(time.Unix(0, 50*1e6)))
if err != nil {
t.Fatalf("Put failed: %s", err)
}
err = insertKeyValue(c, key+"1", "cf", []byte("1"), hrpc.Timestamp(time.Unix(0, 51*1e6)))
if err != nil {
t.Fatalf("Put failed: %s", err)
}
err = insertKeyValue(c, key+"2", "cf", []byte("1"), hrpc.Timestamp(time.Unix(0, 51*1e6)))
if err != nil {
t.Fatalf("Put failed: %s", err)
}
err = insertKeyValue(c, key+"2", "cf", []byte("1"), hrpc.Timestamp(time.Unix(0, 52*1e6)))
if err != nil {
t.Fatalf("Put failed: %s", err)
}
var maxVersions uint32 = 2
scan, err := hrpc.NewScanRangeStr(context.Background(), table,
"TestScanTimeRangeVersions1", "TestScanTimeRangeVersions3",
hrpc.Families(map[string][]string{"cf": nil}), hrpc.TimeRange(time.Unix(0, 50*1e6),
time.Unix(0, 53*1e6)), hrpc.MaxVersions(maxVersions))
if err != nil {
t.Fatalf("Scan req failed: %s", err)
}
rsp, err := c.Scan(scan)
if err != nil {
t.Fatalf("Scan failed: %s", err)
}
if len(rsp) != 2 {
t.Fatalf("Expected rows: %d, Got rows: %d", maxVersions, len(rsp))
}
if uint32(len(rsp[0].Cells)) != maxVersions {
t.Fatalf("Expected versions: %d, Got versions: %d", maxVersions, len(rsp[0].Cells))
}
scan1 := *rsp[0].Cells[0]
if string(scan1.Row) != "TestScanTimeRangeVersions1" && *scan1.Timestamp != 51 {
t.Errorf("Timestamps are not the same. Expected Time: %v, Got Time: %v",
51, *scan1.Timestamp)
}
scan2 := *rsp[0].Cells[1]
if string(scan2.Row) != "TestScanTimeRangeVersions1" && *scan2.Timestamp != 50 {
t.Errorf("Timestamps are not the same. Expected Time: %v, Got Time: %v",
50, *scan2.Timestamp)
}
if uint32(len(rsp[1].Cells)) != maxVersions {
t.Fatalf("Expected versions: %d, Got versions: %d", maxVersions, len(rsp[1].Cells))
}
scan3 := *rsp[1].Cells[0]
if string(scan3.Row) != "TestScanTimeRangeVersions2" && *scan3.Timestamp != 52 {
t.Errorf("Timestamps are not the same. Expected Time: %v, Got Time: %v",
52, *scan3.Timestamp)
}
scan4 := *rsp[1].Cells[1]
if string(scan4.Row) != "TestScanTimeRangeVersions2" && *scan4.Timestamp != 51 {
t.Errorf("Timestamps are not the same. Expected Time: %v, Got Time: %v",
51, *scan4.Timestamp)
}
// scan with no versions set
scan, err = hrpc.NewScanRangeStr(context.Background(), table,
"TestScanTimeRangeVersions1", "TestScanTimeRangeVersions3",
hrpc.Families(map[string][]string{"cf": nil}), hrpc.TimeRange(time.Unix(0, 50*1e6),
time.Unix(0, 53*1e6)))
if err != nil {
t.Fatalf("Scan req failed: %s", err)
}
rsp, err = c.Scan(scan)
if err != nil {
t.Fatalf("Scan failed: %s", err)
}
if len(rsp) != 2 {
t.Fatalf("Expected rows: %d, Got rows: %d", 2, len(rsp))
}
if len(rsp[0].Cells) != 1 {
t.Fatalf("Expected versions: %d, Got versions: %d", 2, len(rsp[0].Cells))
}
if len(rsp[1].Cells) != 1 {
t.Fatalf("Expected versions: %d, Got versions: %d", 2, len(rsp[0].Cells))
}
}
// Scan retrieves the values specified in families from the given range.
func (c *client) Scan(s *hrpc.Scan) ([]*hrpc.Result, error) {
var results []*pb.Result
var scanres *pb.ScanResponse
var rpc *hrpc.Scan
ctx := s.Context()
table := s.Table()
families := s.Families()
filters := s.Filter()
startRow := s.StartRow()
stopRow := s.StopRow()
fromTs, toTs := s.TimeRange()
maxVerions := s.MaxVersions()
numberOfRows := s.NumberOfRows()
for {
// Make a new Scan RPC for this region
if rpc != nil {
// If it's not the first region, we want to start at whatever the
// last region's StopKey was
startRow = rpc.RegionStop()
}
// TODO: would be nicer to clone it in some way
rpc, err := hrpc.NewScanRange(ctx, table, startRow, stopRow,
hrpc.Families(families), hrpc.Filters(filters),
hrpc.TimeRangeUint64(fromTs, toTs),
hrpc.MaxVersions(maxVerions),
hrpc.NumberOfRows(numberOfRows))
if err != nil {
return nil, err
}
res, err := c.sendRPC(rpc)
if err != nil {
return nil, err
}
scanres = res.(*pb.ScanResponse)
results = append(results, scanres.Results...)
// TODO: The more_results field of the ScanResponse object was always
// true, so we should figure out if there's a better way to know when
// to move on to the next region than making an extra request and
// seeing if there were no results
for len(scanres.Results) != 0 {
rpc = hrpc.NewScanFromID(ctx, table, *scanres.ScannerId, rpc.Key())
res, err = c.sendRPC(rpc)
if err != nil {
return nil, err
}
scanres = res.(*pb.ScanResponse)
results = append(results, scanres.Results...)
}
rpc = hrpc.NewCloseFromID(ctx, table, *scanres.ScannerId, rpc.Key())
if err != nil {
return nil, err
}
res, err = c.sendRPC(rpc)
// Check to see if this region is the last we should scan (either
// because (1) it's the last region or (3) because its stop_key is
// greater than or equal to the stop_key of this scanner provided
// that (2) we're not trying to scan until the end of the table).
// (1)
if len(rpc.RegionStop()) == 0 ||
// (2) (3)
len(stopRow) != 0 && bytes.Compare(stopRow, rpc.RegionStop()) <= 0 {
// Do we want to be returning a slice of Result objects or should we just
// put all the Cells into the same Result object?
localResults := make([]*hrpc.Result, len(results))
for idx, result := range results {
localResults[idx] = hrpc.ToLocalResult(result)
}
return localResults, nil
}
}
}
