func main() {
flag.Usage = Usage
var host string
var port int
var protocol string
var urlString string
var framed bool
var useHttp bool
var parsedUrl url.URL
var trans thrift.TTransport
_ = math.MinInt32 // will become unneeded eventually
_ = strconv.Atoi
flag.Usage = Usage
flag.StringVar(&host, "h", "localhost", "Specify host and port")
flag.IntVar(&port, "p", 9090, "Specify port")
flag.StringVar(&protocol, "P", "binary", "Specify the protocol (binary, compact, simplejson, json)")
flag.StringVar(&urlString, "u", "", "Specify the url")
flag.BoolVar(&framed, "framed", false, "Use framed transport")
flag.BoolVar(&useHttp, "http", false, "Use http")
flag.Parse()
if len(urlString) > 0 {
parsedUrl, err := url.Parse(urlString)
if err != nil {
fmt.Fprintln(os.Stderr, "Error parsing URL: ", err)
flag.Usage()
}
host = parsedUrl.Host
useHttp = len(parsedUrl.Scheme) <= 0 || parsedUrl.Scheme == "http"
} else if useHttp {
_, err := url.Parse(fmt.Sprint("http://", host, ":", port))
if err != nil {
fmt.Fprintln(os.Stderr, "Error parsing URL: ", err)
flag.Usage()
}
}
cmd := flag.Arg(0)
var err error
if useHttp {
trans, err = thrift.NewTHttpClient(parsedUrl.String())
} else {
portStr := fmt.Sprint(port)
if strings.Contains(host, ":") {
host, portStr, err = net.SplitHostPort(host)
if err != nil {
fmt.Fprintln(os.Stderr, "error with host:", err)
os.Exit(1)
}
}
trans, err = thrift.NewTSocket(net.JoinHostPort(host, portStr))
if err != nil {
fmt.Fprintln(os.Stderr, "error resolving address:", err)
os.Exit(1)
}
if framed {
trans = thrift.NewTFramedTransport(trans)
}
}
if err != nil {
fmt.Fprintln(os.Stderr, "Error creating transport", err)
os.Exit(1)
}
defer trans.Close()
var protocolFactory thrift.TProtocolFactory
switch protocol {
case "compact":
protocolFactory = thrift.NewTCompactProtocolFactory()
break
case "simplejson":
protocolFactory = thrift.NewTSimpleJSONProtocolFactory()
break
case "json":
protocolFactory = thrift.NewTJSONProtocolFactory()
break
case "binary", "":
protocolFactory = thrift.NewTBinaryProtocolFactoryDefault()
break
default:
fmt.Fprintln(os.Stderr, "Invalid protocol specified: ", protocol)
Usage()
os.Exit(1)
}
client := Hbase.NewHbaseClientFactory(trans, protocolFactory)
if err := trans.Open(); err != nil {
fmt.Fprintln(os.Stderr, "Error opening socket to ", host, ":", port, " ", err)
os.Exit(1)
}
switch cmd {
case "enableTable":
if flag.NArg()-1 != 1 {
fmt.Fprintln(os.Stderr, "EnableTable requires 1 args")
flag.Usage()
}
argvalue0 := flag.Arg(1)
value0 := Hbase.Bytes(argvalue0)
fmt.Print(client.EnableTable(value0))
fmt.Print("\n")
break
case "disableTable":
if flag.NArg()-1 != 1 {
fmt.Fprintln(os.Stderr, "DisableTable requires 1 args")
flag.Usage()
}
argvalue0 := flag.Arg(1)
value0 := Hbase.Bytes(argvalue0)
fmt.Print(client.DisableTable(value0))
fmt.Print("\n")
break
case "isTableEnabled":
if flag.NArg()-1 != 1 {
fmt.Fprintln(os.Stderr, "IsTableEnabled requires 1 args")
flag.Usage()
}
argvalue0 := flag.Arg(1)
value0 := Hbase.Bytes(argvalue0)
fmt.Print(client.IsTableEnabled(value0))
fmt.Print("\n")
break
case "compact":
if flag.NArg()-1 != 1 {
fmt.Fprintln(os.Stderr, "Compact requires 1 args")
flag.Usage()
}
argvalue0 := flag.Arg(1)
value0 := Hbase.Bytes(argvalue0)
fmt.Print(client.Compact(value0))
fmt.Print("\n")
break
case "majorCompact":
if flag.NArg()-1 != 1 {
fmt.Fprintln(os.Stderr, "MajorCompact requires 1 args")
flag.Usage()
}
argvalue0 := flag.Arg(1)
value0 := Hbase.Bytes(argvalue0)
fmt.Print(client.MajorCompact(value0))
fmt.Print("\n")
break
case "getTableNames":
if flag.NArg()-1 != 0 {
fmt.Fprintln(os.Stderr, "GetTableNames requires 0 args")
flag.Usage()
}
fmt.Print(client.GetTableNames())
fmt.Print("\n")
break
case "getColumnDescriptors":
if flag.NArg()-1 != 1 {
fmt.Fprintln(os.Stderr, "GetColumnDescriptors requires 1 args")
flag.Usage()
}
argvalue0 := flag.Arg(1)
value0 := Hbase.Text(argvalue0)
fmt.Print(client.GetColumnDescriptors(value0))
fmt.Print("\n")
break
case "getTableRegions":
if flag.NArg()-1 != 1 {
fmt.Fprintln(os.Stderr, "GetTableRegions requires 1 args")
flag.Usage()
}
argvalue0 := flag.Arg(1)
value0 := Hbase.Text(argvalue0)
fmt.Print(client.GetTableRegions(value0))
fmt.Print("\n")
break
case "createTable":
if flag.NArg()-1 != 2 {
fmt.Fprintln(os.Stderr, "CreateTable requires 2 args")
flag.Usage()
}
argvalue0 := flag.Arg(1)
value0 := Hbase.Text(argvalue0)
arg274 := flag.Arg(2)
mbTrans275 := thrift.NewTMemoryBufferLen(len(arg274))
defer mbTrans275.Close()
_, err276 := mbTrans275.WriteString(arg274)
if err276 != nil {
Usage()
return
}
factory277 := thrift.NewTSimpleJSONProtocolFactory()
jsProt278 := factory277.GetProtocol(mbTrans275)
containerStruct1 := Hbase.NewCreateTableArgs()
err279 := containerStruct1.ReadField2(jsProt278)
if err279 != nil {
Usage()
return
}
argvalue1 := containerStruct1.ColumnFamilies
value1 := argvalue1
fmt.Print(client.CreateTable(value0, value1))
fmt.Print("\n")
break
case "deleteTable":
if flag.NArg()-1 != 1 {
fmt.Fprintln(os.Stderr, "DeleteTable requires 1 args")
flag.Usage()
}
argvalue0 := flag.Arg(1)
value0 := Hbase.Text(argvalue0)
fmt.Print(client.DeleteTable(value0))
fmt.Print("\n")
break
case "get":
if flag.NArg()-1 != 4 {
fmt.Fprintln(os.Stderr, "Get requires 4 args")
flag.Usage()
}
argvalue0 := flag.Arg(1)
value0 := Hbase.Text(argvalue0)
argvalue1 := flag.Arg(2)
value1 := Hbase.Text(argvalue1)
argvalue2 := flag.Arg(3)
value2 := Hbase.Text(argvalue2)
arg284 := flag.Arg(4)
mbTrans285 := thrift.NewTMemoryBufferLen(len(arg284))
defer mbTrans285.Close()
_, err286 := mbTrans285.WriteString(arg284)
if err286 != nil {
Usage()
return
}
factory287 := thrift.NewTSimpleJSONProtocolFactory()
jsProt288 := factory287.GetProtocol(mbTrans285)
containerStruct3 := Hbase.NewGetArgs()
err289 := containerStruct3.ReadField4(jsProt288)
if err289 != nil {
Usage()
return
}
argvalue3 := containerStruct3.Attributes
value3 := argvalue3
fmt.Print(client.Get(value0, value1, value2, value3))
fmt.Print("\n")
break
case "getVer":
if flag.NArg()-1 != 5 {
fmt.Fprintln(os.Stderr, "GetVer requires 5 args")
flag.Usage()
}
argvalue0 := flag.Arg(1)
value0 := Hbase.Text(argvalue0)
argvalue1 := flag.Arg(2)
value1 := Hbase.Text(argvalue1)
argvalue2 := flag.Arg(3)
value2 := Hbase.Text(argvalue2)
tmp3, err293 := (strconv.Atoi(flag.Arg(4)))
if err293 != nil {
Usage()
return
}
argvalue3 := int32(tmp3)
value3 := argvalue3
arg294 := flag.Arg(5)
mbTrans295 := thrift.NewTMemoryBufferLen(len(arg294))
defer mbTrans295.Close()
_, err296 := mbTrans295.WriteString(arg294)
if err296 != nil {
Usage()
return
}
factory297 := thrift.NewTSimpleJSONProtocolFactory()
jsProt298 := factory297.GetProtocol(mbTrans295)
containerStruct4 := Hbase.NewGetVerArgs()
err299 := containerStruct4.ReadField5(jsProt298)
if err299 != nil {
Usage()
return
}
argvalue4 := containerStruct4.Attributes
value4 := argvalue4
fmt.Print(client.GetVer(value0, value1, value2, value3, value4))
fmt.Print("\n")
break
case "getVerTs":
if flag.NArg()-1 != 6 {
fmt.Fprintln(os.Stderr, "GetVerTs requires 6 args")
flag.Usage()
}
argvalue0 := flag.Arg(1)
value0 := Hbase.Text(argvalue0)
argvalue1 := flag.Arg(2)
value1 := Hbase.Text(argvalue1)
argvalue2 := flag.Arg(3)
value2 := Hbase.Text(argvalue2)
argvalue3, err303 := (strconv.ParseInt(flag.Arg(4), 10, 64))
if err303 != nil {
Usage()
return
}
value3 := argvalue3
tmp4, err304 := (strconv.Atoi(flag.Arg(5)))
if err304 != nil {
Usage()
return
}
argvalue4 := int32(tmp4)
value4 := argvalue4
arg305 := flag.Arg(6)
mbTrans306 := thrift.NewTMemoryBufferLen(len(arg305))
defer mbTrans306.Close()
_, err307 := mbTrans306.WriteString(arg305)
if err307 != nil {
Usage()
return
}
factory308 := thrift.NewTSimpleJSONProtocolFactory()
jsProt309 := factory308.GetProtocol(mbTrans306)
containerStruct5 := Hbase.NewGetVerTsArgs()
err310 := containerStruct5.ReadField6(jsProt309)
if err310 != nil {
Usage()
return
}
argvalue5 := containerStruct5.Attributes
value5 := argvalue5
fmt.Print(client.GetVerTs(value0, value1, value2, value3, value4, value5))
fmt.Print("\n")
break
case "getRow":
if flag.NArg()-1 != 3 {
fmt.Fprintln(os.Stderr, "GetRow requires 3 args")
flag.Usage()
}
argvalue0 := flag.Arg(1)
value0 := Hbase.Text(argvalue0)
argvalue1 := flag.Arg(2)
value1 := Hbase.Text(argvalue1)
arg313 := flag.Arg(3)
mbTrans314 := thrift.NewTMemoryBufferLen(len(arg313))
defer mbTrans314.Close()
_, err315 := mbTrans314.WriteString(arg313)
if err315 != nil {
Usage()
return
}
factory316 := thrift.NewTSimpleJSONProtocolFactory()
jsProt317 := factory316.GetProtocol(mbTrans314)
containerStruct2 := Hbase.NewGetRowArgs()
err318 := containerStruct2.ReadField3(jsProt317)
if err318 != nil {
Usage()
return
}
argvalue2 := containerStruct2.Attributes
value2 := argvalue2
fmt.Print(client.GetRow(value0, value1, value2))
fmt.Print("\n")
break
case "getRowWithColumns":
if flag.NArg()-1 != 4 {
fmt.Fprintln(os.Stderr, "GetRowWithColumns requires 4 args")
flag.Usage()
}
argvalue0 := flag.Arg(1)
value0 := Hbase.Text(argvalue0)
argvalue1 := flag.Arg(2)
value1 := Hbase.Text(argvalue1)
arg321 := flag.Arg(3)
mbTrans322 := thrift.NewTMemoryBufferLen(len(arg321))
defer mbTrans322.Close()
_, err323 := mbTrans322.WriteString(arg321)
if err323 != nil {
Usage()
return
}
factory324 := thrift.NewTSimpleJSONProtocolFactory()
jsProt325 := factory324.GetProtocol(mbTrans322)
containerStruct2 := Hbase.NewGetRowWithColumnsArgs()
err326 := containerStruct2.ReadField3(jsProt325)
if err326 != nil {
Usage()
return
}
argvalue2 := containerStruct2.Columns
value2 := argvalue2
arg327 := flag.Arg(4)
mbTrans328 := thrift.NewTMemoryBufferLen(len(arg327))
defer mbTrans328.Close()
_, err329 := mbTrans328.WriteString(arg327)
if err329 != nil {
Usage()
return
}
factory330 := thrift.NewTSimpleJSONProtocolFactory()
jsProt331 := factory330.GetProtocol(mbTrans328)
containerStruct3 := Hbase.NewGetRowWithColumnsArgs()
err332 := containerStruct3.ReadField4(jsProt331)
if err332 != nil {
Usage()
return
}
argvalue3 := containerStruct3.Attributes
value3 := argvalue3
fmt.Print(client.GetRowWithColumns(value0, value1, value2, value3))
fmt.Print("\n")
break
case "getRowTs":
if flag.NArg()-1 != 4 {
fmt.Fprintln(os.Stderr, "GetRowTs requires 4 args")
flag.Usage()
}
argvalue0 := flag.Arg(1)
value0 := Hbase.Text(argvalue0)
argvalue1 := flag.Arg(2)
value1 := Hbase.Text(argvalue1)
argvalue2, err335 := (strconv.ParseInt(flag.Arg(3), 10, 64))
if err335 != nil {
Usage()
return
}
value2 := argvalue2
arg336 := flag.Arg(4)
mbTrans337 := thrift.NewTMemoryBufferLen(len(arg336))
defer mbTrans337.Close()
_, err338 := mbTrans337.WriteString(arg336)
if err338 != nil {
Usage()
return
}
factory339 := thrift.NewTSimpleJSONProtocolFactory()
jsProt340 := factory339.GetProtocol(mbTrans337)
containerStruct3 := Hbase.NewGetRowTsArgs()
err341 := containerStruct3.ReadField4(jsProt340)
if err341 != nil {
Usage()
return
}
argvalue3 := containerStruct3.Attributes
value3 := argvalue3
fmt.Print(client.GetRowTs(value0, value1, value2, value3))
fmt.Print("\n")
break
case "getRowWithColumnsTs":
if flag.NArg()-1 != 5 {
fmt.Fprintln(os.Stderr, "GetRowWithColumnsTs requires 5 args")
flag.Usage()
}
argvalue0 := flag.Arg(1)
value0 := Hbase.Text(argvalue0)
argvalue1 := flag.Arg(2)
value1 := Hbase.Text(argvalue1)
arg344 := flag.Arg(3)
mbTrans345 := thrift.NewTMemoryBufferLen(len(arg344))
defer mbTrans345.Close()
_, err346 := mbTrans345.WriteString(arg344)
if err346 != nil {
Usage()
return
}
factory347 := thrift.NewTSimpleJSONProtocolFactory()
jsProt348 := factory347.GetProtocol(mbTrans345)
containerStruct2 := Hbase.NewGetRowWithColumnsTsArgs()
err349 := containerStruct2.ReadField3(jsProt348)
if err349 != nil {
Usage()
return
}
argvalue2 := containerStruct2.Columns
value2 := argvalue2
argvalue3, err350 := (strconv.ParseInt(flag.Arg(4), 10, 64))
if err350 != nil {
Usage()
return
}
value3 := argvalue3
arg351 := flag.Arg(5)
mbTrans352 := thrift.NewTMemoryBufferLen(len(arg351))
defer mbTrans352.Close()
_, err353 := mbTrans352.WriteString(arg351)
if err353 != nil {
Usage()
return
}
factory354 := thrift.NewTSimpleJSONProtocolFactory()
jsProt355 := factory354.GetProtocol(mbTrans352)
containerStruct4 := Hbase.NewGetRowWithColumnsTsArgs()
err356 := containerStruct4.ReadField5(jsProt355)
if err356 != nil {
Usage()
return
}
argvalue4 := containerStruct4.Attributes
value4 := argvalue4
fmt.Print(client.GetRowWithColumnsTs(value0, value1, value2, value3, value4))
fmt.Print("\n")
break
case "getRows":
if flag.NArg()-1 != 3 {
fmt.Fprintln(os.Stderr, "GetRows requires 3 args")
flag.Usage()
}
argvalue0 := flag.Arg(1)
value0 := Hbase.Text(argvalue0)
arg358 := flag.Arg(2)
mbTrans359 := thrift.NewTMemoryBufferLen(len(arg358))
defer mbTrans359.Close()
_, err360 := mbTrans359.WriteString(arg358)
if err360 != nil {
Usage()
return
}
factory361 := thrift.NewTSimpleJSONProtocolFactory()
jsProt362 := factory361.GetProtocol(mbTrans359)
containerStruct1 := Hbase.NewGetRowsArgs()
err363 := containerStruct1.ReadField2(jsProt362)
if err363 != nil {
Usage()
return
}
argvalue1 := containerStruct1.Rows
value1 := argvalue1
arg364 := flag.Arg(3)
mbTrans365 := thrift.NewTMemoryBufferLen(len(arg364))
defer mbTrans365.Close()
_, err366 := mbTrans365.WriteString(arg364)
if err366 != nil {
Usage()
return
}
factory367 := thrift.NewTSimpleJSONProtocolFactory()
jsProt368 := factory367.GetProtocol(mbTrans365)
containerStruct2 := Hbase.NewGetRowsArgs()
err369 := containerStruct2.ReadField3(jsProt368)
if err369 != nil {
Usage()
return
}
argvalue2 := containerStruct2.Attributes
value2 := argvalue2
fmt.Print(client.GetRows(value0, value1, value2))
fmt.Print("\n")
break
case "getRowsWithColumns":
if flag.NArg()-1 != 4 {
fmt.Fprintln(os.Stderr, "GetRowsWithColumns requires 4 args")
flag.Usage()
}
argvalue0 := flag.Arg(1)
value0 := Hbase.Text(argvalue0)
arg371 := flag.Arg(2)
mbTrans372 := thrift.NewTMemoryBufferLen(len(arg371))
defer mbTrans372.Close()
_, err373 := mbTrans372.WriteString(arg371)
if err373 != nil {
Usage()
return
}
factory374 := thrift.NewTSimpleJSONProtocolFactory()
jsProt375 := factory374.GetProtocol(mbTrans372)
containerStruct1 := Hbase.NewGetRowsWithColumnsArgs()
err376 := containerStruct1.ReadField2(jsProt375)
if err376 != nil {
Usage()
return
}
argvalue1 := containerStruct1.Rows
value1 := argvalue1
arg377 := flag.Arg(3)
mbTrans378 := thrift.NewTMemoryBufferLen(len(arg377))
defer mbTrans378.Close()
_, err379 := mbTrans378.WriteString(arg377)
if err379 != nil {
Usage()
return
}
factory380 := thrift.NewTSimpleJSONProtocolFactory()
jsProt381 := factory380.GetProtocol(mbTrans378)
containerStruct2 := Hbase.NewGetRowsWithColumnsArgs()
err382 := containerStruct2.ReadField3(jsProt381)
if err382 != nil {
Usage()
return
}
argvalue2 := containerStruct2.Columns
value2 := argvalue2
arg383 := flag.Arg(4)
mbTrans384 := thrift.NewTMemoryBufferLen(len(arg383))
defer mbTrans384.Close()
_, err385 := mbTrans384.WriteString(arg383)
if err385 != nil {
Usage()
return
}
factory386 := thrift.NewTSimpleJSONProtocolFactory()
jsProt387 := factory386.GetProtocol(mbTrans384)
containerStruct3 := Hbase.NewGetRowsWithColumnsArgs()
err388 := containerStruct3.ReadField4(jsProt387)
if err388 != nil {
Usage()
return
}
argvalue3 := containerStruct3.Attributes
value3 := argvalue3
fmt.Print(client.GetRowsWithColumns(value0, value1, value2, value3))
fmt.Print("\n")
break
case "getRowsTs":
if flag.NArg()-1 != 4 {
fmt.Fprintln(os.Stderr, "GetRowsTs requires 4 args")
flag.Usage()
}
argvalue0 := flag.Arg(1)
value0 := Hbase.Text(argvalue0)
arg390 := flag.Arg(2)
mbTrans391 := thrift.NewTMemoryBufferLen(len(arg390))
defer mbTrans391.Close()
_, err392 := mbTrans391.WriteString(arg390)
if err392 != nil {
Usage()
return
}
factory393 := thrift.NewTSimpleJSONProtocolFactory()
jsProt394 := factory393.GetProtocol(mbTrans391)
containerStruct1 := Hbase.NewGetRowsTsArgs()
err395 := containerStruct1.ReadField2(jsProt394)
if err395 != nil {
Usage()
return
}
argvalue1 := containerStruct1.Rows
value1 := argvalue1
argvalue2, err396 := (strconv.ParseInt(flag.Arg(3), 10, 64))
if err396 != nil {
Usage()
return
}
value2 := argvalue2
arg397 := flag.Arg(4)
mbTrans398 := thrift.NewTMemoryBufferLen(len(arg397))
defer mbTrans398.Close()
_, err399 := mbTrans398.WriteString(arg397)
if err399 != nil {
Usage()
return
}
factory400 := thrift.NewTSimpleJSONProtocolFactory()
jsProt401 := factory400.GetProtocol(mbTrans398)
containerStruct3 := Hbase.NewGetRowsTsArgs()
err402 := containerStruct3.ReadField4(jsProt401)
if err402 != nil {
Usage()
return
}
argvalue3 := containerStruct3.Attributes
value3 := argvalue3
fmt.Print(client.GetRowsTs(value0, value1, value2, value3))
fmt.Print("\n")
break
case "getRowsWithColumnsTs":
if flag.NArg()-1 != 5 {
fmt.Fprintln(os.Stderr, "GetRowsWithColumnsTs requires 5 args")
flag.Usage()
}
argvalue0 := flag.Arg(1)
value0 := Hbase.Text(argvalue0)
arg404 := flag.Arg(2)
mbTrans405 := thrift.NewTMemoryBufferLen(len(arg404))
defer mbTrans405.Close()
_, err406 := mbTrans405.WriteString(arg404)
if err406 != nil {
Usage()
return
}
factory407 := thrift.NewTSimpleJSONProtocolFactory()
jsProt408 := factory407.GetProtocol(mbTrans405)
containerStruct1 := Hbase.NewGetRowsWithColumnsTsArgs()
err409 := containerStruct1.ReadField2(jsProt408)
if err409 != nil {
Usage()
return
}
argvalue1 := containerStruct1.Rows
value1 := argvalue1
arg410 := flag.Arg(3)
mbTrans411 := thrift.NewTMemoryBufferLen(len(arg410))
defer mbTrans411.Close()
_, err412 := mbTrans411.WriteString(arg410)
if err412 != nil {
Usage()
return
}
factory413 := thrift.NewTSimpleJSONProtocolFactory()
jsProt414 := factory413.GetProtocol(mbTrans411)
containerStruct2 := Hbase.NewGetRowsWithColumnsTsArgs()
err415 := containerStruct2.ReadField3(jsProt414)
if err415 != nil {
Usage()
return
}
argvalue2 := containerStruct2.Columns
value2 := argvalue2
argvalue3, err416 := (strconv.ParseInt(flag.Arg(4), 10, 64))
if err416 != nil {
Usage()
return
}
value3 := argvalue3
arg417 := flag.Arg(5)
mbTrans418 := thrift.NewTMemoryBufferLen(len(arg417))
defer mbTrans418.Close()
_, err419 := mbTrans418.WriteString(arg417)
if err419 != nil {
Usage()
return
}
factory420 := thrift.NewTSimpleJSONProtocolFactory()
jsProt421 := factory420.GetProtocol(mbTrans418)
containerStruct4 := Hbase.NewGetRowsWithColumnsTsArgs()
err422 := containerStruct4.ReadField5(jsProt421)
if err422 != nil {
Usage()
return
}
argvalue4 := containerStruct4.Attributes
value4 := argvalue4
fmt.Print(client.GetRowsWithColumnsTs(value0, value1, value2, value3, value4))
fmt.Print("\n")
break
case "mutateRow":
if flag.NArg()-1 != 4 {
fmt.Fprintln(os.Stderr, "MutateRow requires 4 args")
flag.Usage()
}
argvalue0 := flag.Arg(1)
value0 := Hbase.Text(argvalue0)
argvalue1 := flag.Arg(2)
value1 := Hbase.Text(argvalue1)
arg425 := flag.Arg(3)
mbTrans426 := thrift.NewTMemoryBufferLen(len(arg425))
defer mbTrans426.Close()
_, err427 := mbTrans426.WriteString(arg425)
if err427 != nil {
Usage()
return
}
factory428 := thrift.NewTSimpleJSONProtocolFactory()
jsProt429 := factory428.GetProtocol(mbTrans426)
containerStruct2 := Hbase.NewMutateRowArgs()
err430 := containerStruct2.ReadField3(jsProt429)
if err430 != nil {
Usage()
return
}
argvalue2 := containerStruct2.Mutations
value2 := argvalue2
arg431 := flag.Arg(4)
mbTrans432 := thrift.NewTMemoryBufferLen(len(arg431))
defer mbTrans432.Close()
_, err433 := mbTrans432.WriteString(arg431)
if err433 != nil {
Usage()
return
}
factory434 := thrift.NewTSimpleJSONProtocolFactory()
jsProt435 := factory434.GetProtocol(mbTrans432)
containerStruct3 := Hbase.NewMutateRowArgs()
err436 := containerStruct3.ReadField4(jsProt435)
if err436 != nil {
Usage()
return
}
argvalue3 := containerStruct3.Attributes
value3 := argvalue3
fmt.Print(client.MutateRow(value0, value1, value2, value3))
fmt.Print("\n")
break
case "mutateRowTs":
if flag.NArg()-1 != 5 {
fmt.Fprintln(os.Stderr, "MutateRowTs requires 5 args")
flag.Usage()
}
argvalue0 := flag.Arg(1)
value0 := Hbase.Text(argvalue0)
argvalue1 := flag.Arg(2)
value1 := Hbase.Text(argvalue1)
arg439 := flag.Arg(3)
mbTrans440 := thrift.NewTMemoryBufferLen(len(arg439))
defer mbTrans440.Close()
_, err441 := mbTrans440.WriteString(arg439)
if err441 != nil {
Usage()
return
}
factory442 := thrift.NewTSimpleJSONProtocolFactory()
jsProt443 := factory442.GetProtocol(mbTrans440)
containerStruct2 := Hbase.NewMutateRowTsArgs()
err444 := containerStruct2.ReadField3(jsProt443)
if err444 != nil {
Usage()
return
}
argvalue2 := containerStruct2.Mutations
value2 := argvalue2
argvalue3, err445 := (strconv.ParseInt(flag.Arg(4), 10, 64))
if err445 != nil {
Usage()
return
}
value3 := argvalue3
arg446 := flag.Arg(5)
mbTrans447 := thrift.NewTMemoryBufferLen(len(arg446))
defer mbTrans447.Close()
_, err448 := mbTrans447.WriteString(arg446)
if err448 != nil {
Usage()
return
}
factory449 := thrift.NewTSimpleJSONProtocolFactory()
jsProt450 := factory449.GetProtocol(mbTrans447)
containerStruct4 := Hbase.NewMutateRowTsArgs()
err451 := containerStruct4.ReadField5(jsProt450)
if err451 != nil {
Usage()
return
}
argvalue4 := containerStruct4.Attributes
value4 := argvalue4
fmt.Print(client.MutateRowTs(value0, value1, value2, value3, value4))
fmt.Print("\n")
break
case "mutateRows":
if flag.NArg()-1 != 3 {
fmt.Fprintln(os.Stderr, "MutateRows requires 3 args")
flag.Usage()
}
argvalue0 := flag.Arg(1)
value0 := Hbase.Text(argvalue0)
arg453 := flag.Arg(2)
mbTrans454 := thrift.NewTMemoryBufferLen(len(arg453))
defer mbTrans454.Close()
_, err455 := mbTrans454.WriteString(arg453)
if err455 != nil {
Usage()
return
}
factory456 := thrift.NewTSimpleJSONProtocolFactory()
jsProt457 := factory456.GetProtocol(mbTrans454)
containerStruct1 := Hbase.NewMutateRowsArgs()
err458 := containerStruct1.ReadField2(jsProt457)
if err458 != nil {
Usage()
return
}
argvalue1 := containerStruct1.RowBatches
value1 := argvalue1
arg459 := flag.Arg(3)
mbTrans460 := thrift.NewTMemoryBufferLen(len(arg459))
defer mbTrans460.Close()
_, err461 := mbTrans460.WriteString(arg459)
if err461 != nil {
Usage()
return
}
factory462 := thrift.NewTSimpleJSONProtocolFactory()
jsProt463 := factory462.GetProtocol(mbTrans460)
containerStruct2 := Hbase.NewMutateRowsArgs()
err464 := containerStruct2.ReadField3(jsProt463)
if err464 != nil {
Usage()
return
}
argvalue2 := containerStruct2.Attributes
value2 := argvalue2
fmt.Print(client.MutateRows(value0, value1, value2))
fmt.Print("\n")
break
case "mutateRowsTs":
if flag.NArg()-1 != 4 {
fmt.Fprintln(os.Stderr, "MutateRowsTs requires 4 args")
flag.Usage()
}
argvalue0 := flag.Arg(1)
value0 := Hbase.Text(argvalue0)
arg466 := flag.Arg(2)
mbTrans467 := thrift.NewTMemoryBufferLen(len(arg466))
defer mbTrans467.Close()
_, err468 := mbTrans467.WriteString(arg466)
if err468 != nil {
Usage()
return
}
factory469 := thrift.NewTSimpleJSONProtocolFactory()
jsProt470 := factory469.GetProtocol(mbTrans467)
containerStruct1 := Hbase.NewMutateRowsTsArgs()
err471 := containerStruct1.ReadField2(jsProt470)
if err471 != nil {
Usage()
return
}
argvalue1 := containerStruct1.RowBatches
value1 := argvalue1
argvalue2, err472 := (strconv.ParseInt(flag.Arg(3), 10, 64))
if err472 != nil {
Usage()
return
}
value2 := argvalue2
arg473 := flag.Arg(4)
mbTrans474 := thrift.NewTMemoryBufferLen(len(arg473))
defer mbTrans474.Close()
_, err475 := mbTrans474.WriteString(arg473)
if err475 != nil {
Usage()
return
}
factory476 := thrift.NewTSimpleJSONProtocolFactory()
jsProt477 := factory476.GetProtocol(mbTrans474)
containerStruct3 := Hbase.NewMutateRowsTsArgs()
err478 := containerStruct3.ReadField4(jsProt477)
if err478 != nil {
Usage()
return
}
argvalue3 := containerStruct3.Attributes
value3 := argvalue3
fmt.Print(client.MutateRowsTs(value0, value1, value2, value3))
fmt.Print("\n")
break
case "atomicIncrement":
if flag.NArg()-1 != 4 {
fmt.Fprintln(os.Stderr, "AtomicIncrement requires 4 args")
flag.Usage()
}
argvalue0 := flag.Arg(1)
value0 := Hbase.Text(argvalue0)
argvalue1 := flag.Arg(2)
value1 := Hbase.Text(argvalue1)
argvalue2 := flag.Arg(3)
value2 := Hbase.Text(argvalue2)
argvalue3, err482 := (strconv.ParseInt(flag.Arg(4), 10, 64))
if err482 != nil {
Usage()
return
}
value3 := argvalue3
fmt.Print(client.AtomicIncrement(value0, value1, value2, value3))
fmt.Print("\n")
break
case "deleteAll":
if flag.NArg()-1 != 4 {
fmt.Fprintln(os.Stderr, "DeleteAll requires 4 args")
flag.Usage()
}
argvalue0 := flag.Arg(1)
value0 := Hbase.Text(argvalue0)
argvalue1 := flag.Arg(2)
value1 := Hbase.Text(argvalue1)
argvalue2 := flag.Arg(3)
value2 := Hbase.Text(argvalue2)
arg486 := flag.Arg(4)
mbTrans487 := thrift.NewTMemoryBufferLen(len(arg486))
defer mbTrans487.Close()
_, err488 := mbTrans487.WriteString(arg486)
if err488 != nil {
Usage()
return
}
factory489 := thrift.NewTSimpleJSONProtocolFactory()
jsProt490 := factory489.GetProtocol(mbTrans487)
containerStruct3 := Hbase.NewDeleteAllArgs()
err491 := containerStruct3.ReadField4(jsProt490)
if err491 != nil {
Usage()
return
}
argvalue3 := containerStruct3.Attributes
value3 := argvalue3
fmt.Print(client.DeleteAll(value0, value1, value2, value3))
fmt.Print("\n")
break
case "deleteAllTs":
if flag.NArg()-1 != 5 {
fmt.Fprintln(os.Stderr, "DeleteAllTs requires 5 args")
flag.Usage()
}
argvalue0 := flag.Arg(1)
value0 := Hbase.Text(argvalue0)
argvalue1 := flag.Arg(2)
value1 := Hbase.Text(argvalue1)
argvalue2 := flag.Arg(3)
value2 := Hbase.Text(argvalue2)
argvalue3, err495 := (strconv.ParseInt(flag.Arg(4), 10, 64))
if err495 != nil {
Usage()
return
}
value3 := argvalue3
arg496 := flag.Arg(5)
mbTrans497 := thrift.NewTMemoryBufferLen(len(arg496))
defer mbTrans497.Close()
_, err498 := mbTrans497.WriteString(arg496)
if err498 != nil {
Usage()
return
}
factory499 := thrift.NewTSimpleJSONProtocolFactory()
jsProt500 := factory499.GetProtocol(mbTrans497)
containerStruct4 := Hbase.NewDeleteAllTsArgs()
err501 := containerStruct4.ReadField5(jsProt500)
if err501 != nil {
Usage()
return
}
argvalue4 := containerStruct4.Attributes
value4 := argvalue4
fmt.Print(client.DeleteAllTs(value0, value1, value2, value3, value4))
fmt.Print("\n")
break
case "deleteAllRow":
if flag.NArg()-1 != 3 {
fmt.Fprintln(os.Stderr, "DeleteAllRow requires 3 args")
flag.Usage()
}
argvalue0 := flag.Arg(1)
value0 := Hbase.Text(argvalue0)
argvalue1 := flag.Arg(2)
value1 := Hbase.Text(argvalue1)
arg504 := flag.Arg(3)
mbTrans505 := thrift.NewTMemoryBufferLen(len(arg504))
defer mbTrans505.Close()
_, err506 := mbTrans505.WriteString(arg504)
if err506 != nil {
Usage()
return
}
factory507 := thrift.NewTSimpleJSONProtocolFactory()
jsProt508 := factory507.GetProtocol(mbTrans505)
containerStruct2 := Hbase.NewDeleteAllRowArgs()
err509 := containerStruct2.ReadField3(jsProt508)
if err509 != nil {
Usage()
return
}
argvalue2 := containerStruct2.Attributes
value2 := argvalue2
fmt.Print(client.DeleteAllRow(value0, value1, value2))
fmt.Print("\n")
break
case "increment":
if flag.NArg()-1 != 1 {
fmt.Fprintln(os.Stderr, "Increment requires 1 args")
flag.Usage()
}
arg510 := flag.Arg(1)
mbTrans511 := thrift.NewTMemoryBufferLen(len(arg510))
defer mbTrans511.Close()
_, err512 := mbTrans511.WriteString(arg510)
if err512 != nil {
Usage()
return
}
factory513 := thrift.NewTSimpleJSONProtocolFactory()
jsProt514 := factory513.GetProtocol(mbTrans511)
argvalue0 := Hbase.NewTIncrement()
err515 := argvalue0.Read(jsProt514)
if err515 != nil {
Usage()
return
}
value0 := argvalue0
fmt.Print(client.Increment(value0))
fmt.Print("\n")
break
case "incrementRows":
if flag.NArg()-1 != 1 {
fmt.Fprintln(os.Stderr, "IncrementRows requires 1 args")
flag.Usage()
}
arg516 := flag.Arg(1)
mbTrans517 := thrift.NewTMemoryBufferLen(len(arg516))
defer mbTrans517.Close()
_, err518 := mbTrans517.WriteString(arg516)
if err518 != nil {
Usage()
return
}
factory519 := thrift.NewTSimpleJSONProtocolFactory()
jsProt520 := factory519.GetProtocol(mbTrans517)
containerStruct0 := Hbase.NewIncrementRowsArgs()
err521 := containerStruct0.ReadField1(jsProt520)
if err521 != nil {
Usage()
return
}
argvalue0 := containerStruct0.Increments
value0 := argvalue0
fmt.Print(client.IncrementRows(value0))
fmt.Print("\n")
break
case "deleteAllRowTs":
if flag.NArg()-1 != 4 {
fmt.Fprintln(os.Stderr, "DeleteAllRowTs requires 4 args")
flag.Usage()
}
argvalue0 := flag.Arg(1)
value0 := Hbase.Text(argvalue0)
argvalue1 := flag.Arg(2)
value1 := Hbase.Text(argvalue1)
argvalue2, err524 := (strconv.ParseInt(flag.Arg(3), 10, 64))
if err524 != nil {
Usage()
return
}
value2 := argvalue2
arg525 := flag.Arg(4)
mbTrans526 := thrift.NewTMemoryBufferLen(len(arg525))
defer mbTrans526.Close()
_, err527 := mbTrans526.WriteString(arg525)
if err527 != nil {
Usage()
return
}
factory528 := thrift.NewTSimpleJSONProtocolFactory()
jsProt529 := factory528.GetProtocol(mbTrans526)
containerStruct3 := Hbase.NewDeleteAllRowTsArgs()
err530 := containerStruct3.ReadField4(jsProt529)
if err530 != nil {
Usage()
return
}
argvalue3 := containerStruct3.Attributes
value3 := argvalue3
fmt.Print(client.DeleteAllRowTs(value0, value1, value2, value3))
fmt.Print("\n")
break
case "scannerOpenWithScan":
if flag.NArg()-1 != 3 {
fmt.Fprintln(os.Stderr, "ScannerOpenWithScan requires 3 args")
flag.Usage()
}
argvalue0 := flag.Arg(1)
value0 := Hbase.Text(argvalue0)
arg532 := flag.Arg(2)
mbTrans533 := thrift.NewTMemoryBufferLen(len(arg532))
defer mbTrans533.Close()
_, err534 := mbTrans533.WriteString(arg532)
if err534 != nil {
Usage()
return
}
factory535 := thrift.NewTSimpleJSONProtocolFactory()
jsProt536 := factory535.GetProtocol(mbTrans533)
argvalue1 := Hbase.NewTScan()
err537 := argvalue1.Read(jsProt536)
if err537 != nil {
Usage()
return
}
value1 := argvalue1
arg538 := flag.Arg(3)
mbTrans539 := thrift.NewTMemoryBufferLen(len(arg538))
defer mbTrans539.Close()
_, err540 := mbTrans539.WriteString(arg538)
if err540 != nil {
Usage()
return
}
factory541 := thrift.NewTSimpleJSONProtocolFactory()
jsProt542 := factory541.GetProtocol(mbTrans539)
containerStruct2 := Hbase.NewScannerOpenWithScanArgs()
err543 := containerStruct2.ReadField3(jsProt542)
if err543 != nil {
Usage()
return
}
argvalue2 := containerStruct2.Attributes
value2 := argvalue2
fmt.Print(client.ScannerOpenWithScan(value0, value1, value2))
fmt.Print("\n")
break
case "scannerOpen":
if flag.NArg()-1 != 4 {
fmt.Fprintln(os.Stderr, "ScannerOpen requires 4 args")
flag.Usage()
}
argvalue0 := flag.Arg(1)
value0 := Hbase.Text(argvalue0)
argvalue1 := flag.Arg(2)
value1 := Hbase.Text(argvalue1)
arg546 := flag.Arg(3)
mbTrans547 := thrift.NewTMemoryBufferLen(len(arg546))
defer mbTrans547.Close()
_, err548 := mbTrans547.WriteString(arg546)
if err548 != nil {
Usage()
return
}
factory549 := thrift.NewTSimpleJSONProtocolFactory()
jsProt550 := factory549.GetProtocol(mbTrans547)
containerStruct2 := Hbase.NewScannerOpenArgs()
err551 := containerStruct2.ReadField3(jsProt550)
if err551 != nil {
Usage()
return
}
argvalue2 := containerStruct2.Columns
value2 := argvalue2
arg552 := flag.Arg(4)
mbTrans553 := thrift.NewTMemoryBufferLen(len(arg552))
defer mbTrans553.Close()
_, err554 := mbTrans553.WriteString(arg552)
if err554 != nil {
Usage()
return
}
factory555 := thrift.NewTSimpleJSONProtocolFactory()
jsProt556 := factory555.GetProtocol(mbTrans553)
containerStruct3 := Hbase.NewScannerOpenArgs()
err557 := containerStruct3.ReadField4(jsProt556)
if err557 != nil {
Usage()
return
}
argvalue3 := containerStruct3.Attributes
value3 := argvalue3
fmt.Print(client.ScannerOpen(value0, value1, value2, value3))
fmt.Print("\n")
break
case "scannerOpenWithStop":
if flag.NArg()-1 != 5 {
fmt.Fprintln(os.Stderr, "ScannerOpenWithStop requires 5 args")
flag.Usage()
}
argvalue0 := flag.Arg(1)
value0 := Hbase.Text(argvalue0)
argvalue1 := flag.Arg(2)
value1 := Hbase.Text(argvalue1)
argvalue2 := flag.Arg(3)
value2 := Hbase.Text(argvalue2)
arg561 := flag.Arg(4)
mbTrans562 := thrift.NewTMemoryBufferLen(len(arg561))
defer mbTrans562.Close()
_, err563 := mbTrans562.WriteString(arg561)
if err563 != nil {
Usage()
return
}
factory564 := thrift.NewTSimpleJSONProtocolFactory()
jsProt565 := factory564.GetProtocol(mbTrans562)
containerStruct3 := Hbase.NewScannerOpenWithStopArgs()
err566 := containerStruct3.ReadField4(jsProt565)
if err566 != nil {
Usage()
return
}
argvalue3 := containerStruct3.Columns
value3 := argvalue3
arg567 := flag.Arg(5)
mbTrans568 := thrift.NewTMemoryBufferLen(len(arg567))
defer mbTrans568.Close()
_, err569 := mbTrans568.WriteString(arg567)
if err569 != nil {
Usage()
return
}
factory570 := thrift.NewTSimpleJSONProtocolFactory()
jsProt571 := factory570.GetProtocol(mbTrans568)
containerStruct4 := Hbase.NewScannerOpenWithStopArgs()
err572 := containerStruct4.ReadField5(jsProt571)
if err572 != nil {
Usage()
return
}
argvalue4 := containerStruct4.Attributes
value4 := argvalue4
fmt.Print(client.ScannerOpenWithStop(value0, value1, value2, value3, value4))
fmt.Print("\n")
break
case "scannerOpenWithPrefix":
if flag.NArg()-1 != 4 {
fmt.Fprintln(os.Stderr, "ScannerOpenWithPrefix requires 4 args")
flag.Usage()
}
argvalue0 := flag.Arg(1)
value0 := Hbase.Text(argvalue0)
argvalue1 := flag.Arg(2)
value1 := Hbase.Text(argvalue1)
arg575 := flag.Arg(3)
mbTrans576 := thrift.NewTMemoryBufferLen(len(arg575))
defer mbTrans576.Close()
_, err577 := mbTrans576.WriteString(arg575)
if err577 != nil {
Usage()
return
}
factory578 := thrift.NewTSimpleJSONProtocolFactory()
jsProt579 := factory578.GetProtocol(mbTrans576)
containerStruct2 := Hbase.NewScannerOpenWithPrefixArgs()
err580 := containerStruct2.ReadField3(jsProt579)
if err580 != nil {
Usage()
return
}
argvalue2 := containerStruct2.Columns
value2 := argvalue2
arg581 := flag.Arg(4)
mbTrans582 := thrift.NewTMemoryBufferLen(len(arg581))
defer mbTrans582.Close()
_, err583 := mbTrans582.WriteString(arg581)
if err583 != nil {
Usage()
return
}
factory584 := thrift.NewTSimpleJSONProtocolFactory()
jsProt585 := factory584.GetProtocol(mbTrans582)
containerStruct3 := Hbase.NewScannerOpenWithPrefixArgs()
err586 := containerStruct3.ReadField4(jsProt585)
if err586 != nil {
Usage()
return
}
argvalue3 := containerStruct3.Attributes
value3 := argvalue3
fmt.Print(client.ScannerOpenWithPrefix(value0, value1, value2, value3))
fmt.Print("\n")
break
case "scannerOpenTs":
if flag.NArg()-1 != 5 {
fmt.Fprintln(os.Stderr, "ScannerOpenTs requires 5 args")
flag.Usage()
}
argvalue0 := flag.Arg(1)
value0 := Hbase.Text(argvalue0)
argvalue1 := flag.Arg(2)
value1 := Hbase.Text(argvalue1)
arg589 := flag.Arg(3)
mbTrans590 := thrift.NewTMemoryBufferLen(len(arg589))
defer mbTrans590.Close()
_, err591 := mbTrans590.WriteString(arg589)
if err591 != nil {
Usage()
return
}
factory592 := thrift.NewTSimpleJSONProtocolFactory()
jsProt593 := factory592.GetProtocol(mbTrans590)
containerStruct2 := Hbase.NewScannerOpenTsArgs()
err594 := containerStruct2.ReadField3(jsProt593)
if err594 != nil {
Usage()
return
}
argvalue2 := containerStruct2.Columns
value2 := argvalue2
argvalue3, err595 := (strconv.ParseInt(flag.Arg(4), 10, 64))
if err595 != nil {
Usage()
return
}
value3 := argvalue3
arg596 := flag.Arg(5)
mbTrans597 := thrift.NewTMemoryBufferLen(len(arg596))
defer mbTrans597.Close()
_, err598 := mbTrans597.WriteString(arg596)
if err598 != nil {
Usage()
return
}
factory599 := thrift.NewTSimpleJSONProtocolFactory()
jsProt600 := factory599.GetProtocol(mbTrans597)
containerStruct4 := Hbase.NewScannerOpenTsArgs()
err601 := containerStruct4.ReadField5(jsProt600)
if err601 != nil {
Usage()
return
}
argvalue4 := containerStruct4.Attributes
value4 := argvalue4
fmt.Print(client.ScannerOpenTs(value0, value1, value2, value3, value4))
fmt.Print("\n")
break
case "scannerOpenWithStopTs":
if flag.NArg()-1 != 6 {
fmt.Fprintln(os.Stderr, "ScannerOpenWithStopTs requires 6 args")
flag.Usage()
}
argvalue0 := flag.Arg(1)
value0 := Hbase.Text(argvalue0)
argvalue1 := flag.Arg(2)
value1 := Hbase.Text(argvalue1)
argvalue2 := flag.Arg(3)
value2 := Hbase.Text(argvalue2)
arg605 := flag.Arg(4)
mbTrans606 := thrift.NewTMemoryBufferLen(len(arg605))
defer mbTrans606.Close()
_, err607 := mbTrans606.WriteString(arg605)
if err607 != nil {
Usage()
return
}
factory608 := thrift.NewTSimpleJSONProtocolFactory()
jsProt609 := factory608.GetProtocol(mbTrans606)
containerStruct3 := Hbase.NewScannerOpenWithStopTsArgs()
err610 := containerStruct3.ReadField4(jsProt609)
if err610 != nil {
Usage()
return
}
argvalue3 := containerStruct3.Columns
value3 := argvalue3
argvalue4, err611 := (strconv.ParseInt(flag.Arg(5), 10, 64))
if err611 != nil {
Usage()
return
}
value4 := argvalue4
arg612 := flag.Arg(6)
mbTrans613 := thrift.NewTMemoryBufferLen(len(arg612))
defer mbTrans613.Close()
_, err614 := mbTrans613.WriteString(arg612)
if err614 != nil {
Usage()
return
}
factory615 := thrift.NewTSimpleJSONProtocolFactory()
jsProt616 := factory615.GetProtocol(mbTrans613)
containerStruct5 := Hbase.NewScannerOpenWithStopTsArgs()
err617 := containerStruct5.ReadField6(jsProt616)
if err617 != nil {
Usage()
return
}
argvalue5 := containerStruct5.Attributes
value5 := argvalue5
fmt.Print(client.ScannerOpenWithStopTs(value0, value1, value2, value3, value4, value5))
fmt.Print("\n")
break
case "scannerGet":
if flag.NArg()-1 != 1 {
fmt.Fprintln(os.Stderr, "ScannerGet requires 1 args")
flag.Usage()
}
tmp0, err618 := (strconv.Atoi(flag.Arg(1)))
if err618 != nil {
Usage()
return
}
argvalue0 := int32(tmp0)
value0 := Hbase.ScannerID(argvalue0)
fmt.Print(client.ScannerGet(value0))
fmt.Print("\n")
break
case "scannerGetList":
if flag.NArg()-1 != 2 {
fmt.Fprintln(os.Stderr, "ScannerGetList requires 2 args")
flag.Usage()
}
tmp0, err619 := (strconv.Atoi(flag.Arg(1)))
if err619 != nil {
Usage()
return
}
argvalue0 := int32(tmp0)
value0 := Hbase.ScannerID(argvalue0)
tmp1, err620 := (strconv.Atoi(flag.Arg(2)))
if err620 != nil {
Usage()
return
}
argvalue1 := int32(tmp1)
value1 := argvalue1
fmt.Print(client.ScannerGetList(value0, value1))
fmt.Print("\n")
break
case "scannerClose":
if flag.NArg()-1 != 1 {
fmt.Fprintln(os.Stderr, "ScannerClose requires 1 args")
flag.Usage()
}
tmp0, err621 := (strconv.Atoi(flag.Arg(1)))
if err621 != nil {
Usage()
return
}
argvalue0 := int32(tmp0)
value0 := Hbase.ScannerID(argvalue0)
fmt.Print(client.ScannerClose(value0))
fmt.Print("\n")
break
case "getRowOrBefore":
if flag.NArg()-1 != 3 {
fmt.Fprintln(os.Stderr, "GetRowOrBefore requires 3 args")
flag.Usage()
}
argvalue0 := flag.Arg(1)
value0 := Hbase.Text(argvalue0)
argvalue1 := flag.Arg(2)
value1 := Hbase.Text(argvalue1)
argvalue2 := flag.Arg(3)
value2 := Hbase.Text(argvalue2)
fmt.Print(client.GetRowOrBefore(value0, value1, value2))
fmt.Print("\n")
break
case "getRegionInfo":
if flag.NArg()-1 != 1 {
fmt.Fprintln(os.Stderr, "GetRegionInfo requires 1 args")
flag.Usage()
}
argvalue0 := flag.Arg(1)
value0 := Hbase.Text(argvalue0)
fmt.Print(client.GetRegionInfo(value0))
fmt.Print("\n")
break
case "":
Usage()
break
default:
fmt.Fprintln(os.Stderr, "Invalid function ", cmd)
}
}
func main() {
flag.Usage = Usage
var host string
var port int
var protocol string
var urlString string
var framed bool
var useHttp bool
var help bool
var parsedUrl url.URL
var trans thrift.TTransport
flag.Usage = Usage
flag.StringVar(&host, "h", "localhost", "Specify host and port")
flag.IntVar(&port, "p", 9090, "Specify port")
flag.StringVar(&protocol, "P", "binary", "Specify the protocol (binary, compact, simplejson, json)")
flag.StringVar(&urlString, "u", "", "Specify the url")
flag.BoolVar(&framed, "framed", false, "Use framed transport")
flag.BoolVar(&useHttp, "http", false, "Use http")
flag.BoolVar(&help, "help", false, "See usage string")
flag.Parse()
if help || flag.NArg() == 0 {
flag.Usage()
}
if len(urlString) > 0 {
parsedUrl, err := url.Parse(urlString)
if err != nil {
fmt.Fprint(os.Stderr, "Error parsing URL: ", err.Error(), "\n")
flag.Usage()
}
host = parsedUrl.Host
useHttp = len(parsedUrl.Scheme) <= 0 || parsedUrl.Scheme == "http"
} else if useHttp {
_, err := url.Parse(fmt.Sprint("http://", host, ":", port))
if err != nil {
fmt.Fprint(os.Stderr, "Error parsing URL: ", err.Error(), "\n")
flag.Usage()
}
}
cmd := flag.Arg(0)
var err error
if useHttp {
trans, err = thrift.NewTHttpClient(parsedUrl.String())
} else {
addr, err := net.ResolveTCPAddr("tcp", fmt.Sprint(host, ":", port))
if err != nil {
fmt.Fprint(os.Stderr, "Error resolving address", err.Error())
os.Exit(1)
}
trans, err = thrift.NewTNonblockingSocketAddr(addr)
if framed {
trans = thrift.NewTFramedTransport(trans)
}
}
if err != nil {
fmt.Fprint(os.Stderr, "Error creating transport", err.Error())
os.Exit(1)
}
defer trans.Close()
var protocolFactory thrift.TProtocolFactory
switch protocol {
case "compact":
protocolFactory = thrift.NewTCompactProtocolFactory()
break
case "simplejson":
protocolFactory = thrift.NewTSimpleJSONProtocolFactory()
break
case "json":
protocolFactory = thrift.NewTJSONProtocolFactory()
break
case "binary", "":
protocolFactory = thrift.NewTBinaryProtocolFactoryDefault()
break
default:
fmt.Fprint(os.Stderr, "Invalid protocol specified: ", protocol, "\n")
Usage()
os.Exit(1)
}
client := Hbase.NewHbaseClientFactory(trans, protocolFactory)
if err = trans.Open(); err != nil {
fmt.Fprint(os.Stderr, "Error opening socket to ", host, ":", port, " ", err.Error())
os.Exit(1)
}
switch cmd {
case "enableTable":
if flag.NArg()-1 != 1 {
fmt.Fprint(os.Stderr, "EnableTable requires 1 args\n")
flag.Usage()
}
argvalue0 := flag.Arg(1)
value0 := Hbase.Bytes(argvalue0)
fmt.Print(client.EnableTable(value0))
fmt.Print("\n")
break
case "disableTable":
if flag.NArg()-1 != 1 {
fmt.Fprint(os.Stderr, "DisableTable requires 1 args\n")
flag.Usage()
}
argvalue0 := flag.Arg(1)
value0 := Hbase.Bytes(argvalue0)
fmt.Print(client.DisableTable(value0))
fmt.Print("\n")
break
case "isTableEnabled":
if flag.NArg()-1 != 1 {
fmt.Fprint(os.Stderr, "IsTableEnabled requires 1 args\n")
flag.Usage()
}
argvalue0 := flag.Arg(1)
value0 := Hbase.Bytes(argvalue0)
fmt.Print(client.IsTableEnabled(value0))
fmt.Print("\n")
break
case "compact":
if flag.NArg()-1 != 1 {
fmt.Fprint(os.Stderr, "Compact requires 1 args\n")
flag.Usage()
}
argvalue0 := flag.Arg(1)
value0 := Hbase.Bytes(argvalue0)
fmt.Print(client.Compact(value0))
fmt.Print("\n")
break
case "majorCompact":
if flag.NArg()-1 != 1 {
fmt.Fprint(os.Stderr, "MajorCompact requires 1 args\n")
flag.Usage()
}
argvalue0 := flag.Arg(1)
value0 := Hbase.Bytes(argvalue0)
fmt.Print(client.MajorCompact(value0))
fmt.Print("\n")
break
case "getTableNames":
if flag.NArg()-1 != 0 {
fmt.Fprint(os.Stderr, "GetTableNames requires 0 args\n")
flag.Usage()
}
fmt.Print(client.GetTableNames())
fmt.Print("\n")
break
case "getColumnDescriptors":
if flag.NArg()-1 != 1 {
fmt.Fprint(os.Stderr, "GetColumnDescriptors requires 1 args\n")
flag.Usage()
}
argvalue0 := flag.Arg(1)
value0 := Hbase.Text(argvalue0)
fmt.Print(client.GetColumnDescriptors(value0))
fmt.Print("\n")
break
case "getTableRegions":
if flag.NArg()-1 != 1 {
fmt.Fprint(os.Stderr, "GetTableRegions requires 1 args\n")
flag.Usage()
}
argvalue0 := flag.Arg(1)
value0 := Hbase.Text(argvalue0)
fmt.Print(client.GetTableRegions(value0))
fmt.Print("\n")
break
case "createTable":
if flag.NArg()-1 != 2 {
fmt.Fprint(os.Stderr, "CreateTable requires 2 args\n")
flag.Usage()
}
argvalue0 := flag.Arg(1)
value0 := Hbase.Text(argvalue0)
arg1635 := flag.Arg(2)
mbTrans1636 := thrift.NewTMemoryBufferLen(len(arg1635))
defer mbTrans1636.Close()
_, err1637 := mbTrans1636.WriteString(arg1635)
if err1637 != nil {
Usage()
return
}
factory1638 := thrift.NewTSimpleJSONProtocolFactory()
jsProt1639 := factory1638.GetProtocol(mbTrans1636)
containerStruct1 := Hbase.NewCreateTableArgs()
err1640 := containerStruct1.ReadField2(jsProt1639)
if err1640 != nil {
Usage()
return
}
argvalue1 := containerStruct1.ColumnFamilies
value1 := argvalue1
fmt.Print(client.CreateTable(value0, value1))
fmt.Print("\n")
break
case "deleteTable":
if flag.NArg()-1 != 1 {
fmt.Fprint(os.Stderr, "DeleteTable requires 1 args\n")
flag.Usage()
}
argvalue0 := flag.Arg(1)
value0 := Hbase.Text(argvalue0)
fmt.Print(client.DeleteTable(value0))
fmt.Print("\n")
break
case "get":
if flag.NArg()-1 != 4 {
fmt.Fprint(os.Stderr, "Get requires 4 args\n")
flag.Usage()
}
argvalue0 := flag.Arg(1)
value0 := Hbase.Text(argvalue0)
argvalue1 := flag.Arg(2)
value1 := Hbase.Text(argvalue1)
argvalue2 := flag.Arg(3)
value2 := Hbase.Text(argvalue2)
arg1645 := flag.Arg(4)
mbTrans1646 := thrift.NewTMemoryBufferLen(len(arg1645))
defer mbTrans1646.Close()
_, err1647 := mbTrans1646.WriteString(arg1645)
if err1647 != nil {
Usage()
return
}
factory1648 := thrift.NewTSimpleJSONProtocolFactory()
jsProt1649 := factory1648.GetProtocol(mbTrans1646)
containerStruct3 := Hbase.NewGetArgs()
err1650 := containerStruct3.ReadField4(jsProt1649)
if err1650 != nil {
Usage()
return
}
argvalue3 := containerStruct3.Attributes
value3 := argvalue3
fmt.Print(client.Get(value0, value1, value2, value3))
fmt.Print("\n")
break
case "getVer":
if flag.NArg()-1 != 5 {
fmt.Fprint(os.Stderr, "GetVer requires 5 args\n")
flag.Usage()
}
argvalue0 := flag.Arg(1)
value0 := Hbase.Text(argvalue0)
argvalue1 := flag.Arg(2)
value1 := Hbase.Text(argvalue1)
argvalue2 := flag.Arg(3)
value2 := Hbase.Text(argvalue2)
tmp3, err1654 := (strconv.Atoi(flag.Arg(4)))
if err1654 != nil {
Usage()
return
}
argvalue3 := int32(tmp3)
value3 := argvalue3
arg1655 := flag.Arg(5)
mbTrans1656 := thrift.NewTMemoryBufferLen(len(arg1655))
defer mbTrans1656.Close()
_, err1657 := mbTrans1656.WriteString(arg1655)
if err1657 != nil {
Usage()
return
}
factory1658 := thrift.NewTSimpleJSONProtocolFactory()
jsProt1659 := factory1658.GetProtocol(mbTrans1656)
containerStruct4 := Hbase.NewGetVerArgs()
err1660 := containerStruct4.ReadField5(jsProt1659)
if err1660 != nil {
Usage()
return
}
argvalue4 := containerStruct4.Attributes
value4 := argvalue4
fmt.Print(client.GetVer(value0, value1, value2, value3, value4))
fmt.Print("\n")
break
case "getVerTs":
if flag.NArg()-1 != 6 {
fmt.Fprint(os.Stderr, "GetVerTs requires 6 args\n")
flag.Usage()
}
argvalue0 := flag.Arg(1)
value0 := Hbase.Text(argvalue0)
argvalue1 := flag.Arg(2)
value1 := Hbase.Text(argvalue1)
argvalue2 := flag.Arg(3)
value2 := Hbase.Text(argvalue2)
argvalue3, err1664 := (strconv.ParseInt(flag.Arg(4), 10, 64))
if err1664 != nil {
Usage()
return
}
value3 := argvalue3
tmp4, err1665 := (strconv.Atoi(flag.Arg(5)))
if err1665 != nil {
Usage()
return
}
argvalue4 := int32(tmp4)
value4 := argvalue4
arg1666 := flag.Arg(6)
mbTrans1667 := thrift.NewTMemoryBufferLen(len(arg1666))
defer mbTrans1667.Close()
_, err1668 := mbTrans1667.WriteString(arg1666)
if err1668 != nil {
Usage()
return
}
factory1669 := thrift.NewTSimpleJSONProtocolFactory()
jsProt1670 := factory1669.GetProtocol(mbTrans1667)
containerStruct5 := Hbase.NewGetVerTsArgs()
err1671 := containerStruct5.ReadField6(jsProt1670)
if err1671 != nil {
Usage()
return
}
argvalue5 := containerStruct5.Attributes
value5 := argvalue5
fmt.Print(client.GetVerTs(value0, value1, value2, value3, value4, value5))
fmt.Print("\n")
break
case "getRow":
if flag.NArg()-1 != 3 {
fmt.Fprint(os.Stderr, "GetRow requires 3 args\n")
flag.Usage()
}
argvalue0 := flag.Arg(1)
value0 := Hbase.Text(argvalue0)
argvalue1 := flag.Arg(2)
value1 := Hbase.Text(argvalue1)
arg1674 := flag.Arg(3)
mbTrans1675 := thrift.NewTMemoryBufferLen(len(arg1674))
defer mbTrans1675.Close()
_, err1676 := mbTrans1675.WriteString(arg1674)
if err1676 != nil {
Usage()
return
}
factory1677 := thrift.NewTSimpleJSONProtocolFactory()
jsProt1678 := factory1677.GetProtocol(mbTrans1675)
containerStruct2 := Hbase.NewGetRowArgs()
err1679 := containerStruct2.ReadField3(jsProt1678)
if err1679 != nil {
Usage()
return
}
argvalue2 := containerStruct2.Attributes
value2 := argvalue2
fmt.Print(client.GetRow(value0, value1, value2))
fmt.Print("\n")
break
case "getRowWithColumns":
if flag.NArg()-1 != 4 {
fmt.Fprint(os.Stderr, "GetRowWithColumns requires 4 args\n")
flag.Usage()
}
argvalue0 := flag.Arg(1)
value0 := Hbase.Text(argvalue0)
argvalue1 := flag.Arg(2)
value1 := Hbase.Text(argvalue1)
arg1682 := flag.Arg(3)
mbTrans1683 := thrift.NewTMemoryBufferLen(len(arg1682))
defer mbTrans1683.Close()
_, err1684 := mbTrans1683.WriteString(arg1682)
if err1684 != nil {
Usage()
return
}
factory1685 := thrift.NewTSimpleJSONProtocolFactory()
jsProt1686 := factory1685.GetProtocol(mbTrans1683)
containerStruct2 := Hbase.NewGetRowWithColumnsArgs()
err1687 := containerStruct2.ReadField3(jsProt1686)
if err1687 != nil {
Usage()
return
}
argvalue2 := containerStruct2.Columns
value2 := argvalue2
arg1688 := flag.Arg(4)
mbTrans1689 := thrift.NewTMemoryBufferLen(len(arg1688))
defer mbTrans1689.Close()
_, err1690 := mbTrans1689.WriteString(arg1688)
if err1690 != nil {
Usage()
return
}
factory1691 := thrift.NewTSimpleJSONProtocolFactory()
jsProt1692 := factory1691.GetProtocol(mbTrans1689)
containerStruct3 := Hbase.NewGetRowWithColumnsArgs()
err1693 := containerStruct3.ReadField4(jsProt1692)
if err1693 != nil {
Usage()
return
}
argvalue3 := containerStruct3.Attributes
value3 := argvalue3
fmt.Print(client.GetRowWithColumns(value0, value1, value2, value3))
fmt.Print("\n")
break
case "getRowTs":
if flag.NArg()-1 != 4 {
fmt.Fprint(os.Stderr, "GetRowTs requires 4 args\n")
flag.Usage()
}
argvalue0 := flag.Arg(1)
value0 := Hbase.Text(argvalue0)
argvalue1 := flag.Arg(2)
value1 := Hbase.Text(argvalue1)
argvalue2, err1696 := (strconv.ParseInt(flag.Arg(3), 10, 64))
if err1696 != nil {
Usage()
return
}
value2 := argvalue2
arg1697 := flag.Arg(4)
mbTrans1698 := thrift.NewTMemoryBufferLen(len(arg1697))
defer mbTrans1698.Close()
_, err1699 := mbTrans1698.WriteString(arg1697)
if err1699 != nil {
Usage()
return
}
factory1700 := thrift.NewTSimpleJSONProtocolFactory()
jsProt1701 := factory1700.GetProtocol(mbTrans1698)
containerStruct3 := Hbase.NewGetRowTsArgs()
err1702 := containerStruct3.ReadField4(jsProt1701)
if err1702 != nil {
Usage()
return
}
argvalue3 := containerStruct3.Attributes
value3 := argvalue3
fmt.Print(client.GetRowTs(value0, value1, value2, value3))
fmt.Print("\n")
break
case "getRowWithColumnsTs":
if flag.NArg()-1 != 5 {
fmt.Fprint(os.Stderr, "GetRowWithColumnsTs requires 5 args\n")
flag.Usage()
}
argvalue0 := flag.Arg(1)
value0 := Hbase.Text(argvalue0)
argvalue1 := flag.Arg(2)
value1 := Hbase.Text(argvalue1)
arg1705 := flag.Arg(3)
mbTrans1706 := thrift.NewTMemoryBufferLen(len(arg1705))
defer mbTrans1706.Close()
_, err1707 := mbTrans1706.WriteString(arg1705)
if err1707 != nil {
Usage()
return
}
factory1708 := thrift.NewTSimpleJSONProtocolFactory()
jsProt1709 := factory1708.GetProtocol(mbTrans1706)
containerStruct2 := Hbase.NewGetRowWithColumnsTsArgs()
err1710 := containerStruct2.ReadField3(jsProt1709)
if err1710 != nil {
Usage()
return
}
argvalue2 := containerStruct2.Columns
value2 := argvalue2
argvalue3, err1711 := (strconv.ParseInt(flag.Arg(4), 10, 64))
if err1711 != nil {
Usage()
return
}
value3 := argvalue3
arg1712 := flag.Arg(5)
mbTrans1713 := thrift.NewTMemoryBufferLen(len(arg1712))
defer mbTrans1713.Close()
_, err1714 := mbTrans1713.WriteString(arg1712)
if err1714 != nil {
Usage()
return
}
factory1715 := thrift.NewTSimpleJSONProtocolFactory()
jsProt1716 := factory1715.GetProtocol(mbTrans1713)
containerStruct4 := Hbase.NewGetRowWithColumnsTsArgs()
err1717 := containerStruct4.ReadField5(jsProt1716)
if err1717 != nil {
Usage()
return
}
argvalue4 := containerStruct4.Attributes
value4 := argvalue4
fmt.Print(client.GetRowWithColumnsTs(value0, value1, value2, value3, value4))
fmt.Print("\n")
break
case "getRows":
if flag.NArg()-1 != 3 {
fmt.Fprint(os.Stderr, "GetRows requires 3 args\n")
flag.Usage()
}
argvalue0 := flag.Arg(1)
value0 := Hbase.Text(argvalue0)
arg1719 := flag.Arg(2)
mbTrans1720 := thrift.NewTMemoryBufferLen(len(arg1719))
defer mbTrans1720.Close()
_, err1721 := mbTrans1720.WriteString(arg1719)
if err1721 != nil {
Usage()
return
}
factory1722 := thrift.NewTSimpleJSONProtocolFactory()
jsProt1723 := factory1722.GetProtocol(mbTrans1720)
containerStruct1 := Hbase.NewGetRowsArgs()
err1724 := containerStruct1.ReadField2(jsProt1723)
if err1724 != nil {
Usage()
return
}
argvalue1 := containerStruct1.Rows
value1 := argvalue1
arg1725 := flag.Arg(3)
mbTrans1726 := thrift.NewTMemoryBufferLen(len(arg1725))
defer mbTrans1726.Close()
_, err1727 := mbTrans1726.WriteString(arg1725)
if err1727 != nil {
Usage()
return
}
factory1728 := thrift.NewTSimpleJSONProtocolFactory()
jsProt1729 := factory1728.GetProtocol(mbTrans1726)
containerStruct2 := Hbase.NewGetRowsArgs()
err1730 := containerStruct2.ReadField3(jsProt1729)
if err1730 != nil {
Usage()
return
}
argvalue2 := containerStruct2.Attributes
value2 := argvalue2
fmt.Print(client.GetRows(value0, value1, value2))
fmt.Print("\n")
break
case "getRowsWithColumns":
if flag.NArg()-1 != 4 {
fmt.Fprint(os.Stderr, "GetRowsWithColumns requires 4 args\n")
flag.Usage()
}
argvalue0 := flag.Arg(1)
value0 := Hbase.Text(argvalue0)
arg1732 := flag.Arg(2)
mbTrans1733 := thrift.NewTMemoryBufferLen(len(arg1732))
defer mbTrans1733.Close()
_, err1734 := mbTrans1733.WriteString(arg1732)
if err1734 != nil {
Usage()
return
}
factory1735 := thrift.NewTSimpleJSONProtocolFactory()
jsProt1736 := factory1735.GetProtocol(mbTrans1733)
containerStruct1 := Hbase.NewGetRowsWithColumnsArgs()
err1737 := containerStruct1.ReadField2(jsProt1736)
if err1737 != nil {
Usage()
return
}
argvalue1 := containerStruct1.Rows
value1 := argvalue1
arg1738 := flag.Arg(3)
mbTrans1739 := thrift.NewTMemoryBufferLen(len(arg1738))
defer mbTrans1739.Close()
_, err1740 := mbTrans1739.WriteString(arg1738)
if err1740 != nil {
Usage()
return
}
factory1741 := thrift.NewTSimpleJSONProtocolFactory()
jsProt1742 := factory1741.GetProtocol(mbTrans1739)
containerStruct2 := Hbase.NewGetRowsWithColumnsArgs()
err1743 := containerStruct2.ReadField3(jsProt1742)
if err1743 != nil {
Usage()
return
}
argvalue2 := containerStruct2.Columns
value2 := argvalue2
arg1744 := flag.Arg(4)
mbTrans1745 := thrift.NewTMemoryBufferLen(len(arg1744))
defer mbTrans1745.Close()
_, err1746 := mbTrans1745.WriteString(arg1744)
if err1746 != nil {
Usage()
return
}
factory1747 := thrift.NewTSimpleJSONProtocolFactory()
jsProt1748 := factory1747.GetProtocol(mbTrans1745)
containerStruct3 := Hbase.NewGetRowsWithColumnsArgs()
err1749 := containerStruct3.ReadField4(jsProt1748)
if err1749 != nil {
Usage()
return
}
argvalue3 := containerStruct3.Attributes
value3 := argvalue3
fmt.Print(client.GetRowsWithColumns(value0, value1, value2, value3))
fmt.Print("\n")
break
case "getRowsTs":
if flag.NArg()-1 != 4 {
fmt.Fprint(os.Stderr, "GetRowsTs requires 4 args\n")
flag.Usage()
}
argvalue0 := flag.Arg(1)
value0 := Hbase.Text(argvalue0)
arg1751 := flag.Arg(2)
mbTrans1752 := thrift.NewTMemoryBufferLen(len(arg1751))
defer mbTrans1752.Close()
_, err1753 := mbTrans1752.WriteString(arg1751)
if err1753 != nil {
Usage()
return
}
factory1754 := thrift.NewTSimpleJSONProtocolFactory()
jsProt1755 := factory1754.GetProtocol(mbTrans1752)
containerStruct1 := Hbase.NewGetRowsTsArgs()
err1756 := containerStruct1.ReadField2(jsProt1755)
if err1756 != nil {
Usage()
return
}
argvalue1 := containerStruct1.Rows
value1 := argvalue1
argvalue2, err1757 := (strconv.ParseInt(flag.Arg(3), 10, 64))
if err1757 != nil {
Usage()
return
}
value2 := argvalue2
arg1758 := flag.Arg(4)
mbTrans1759 := thrift.NewTMemoryBufferLen(len(arg1758))
defer mbTrans1759.Close()
_, err1760 := mbTrans1759.WriteString(arg1758)
if err1760 != nil {
Usage()
return
}
factory1761 := thrift.NewTSimpleJSONProtocolFactory()
jsProt1762 := factory1761.GetProtocol(mbTrans1759)
containerStruct3 := Hbase.NewGetRowsTsArgs()
err1763 := containerStruct3.ReadField4(jsProt1762)
if err1763 != nil {
Usage()
return
}
argvalue3 := containerStruct3.Attributes
value3 := argvalue3
fmt.Print(client.GetRowsTs(value0, value1, value2, value3))
fmt.Print("\n")
break
case "getRowsWithColumnsTs":
if flag.NArg()-1 != 5 {
fmt.Fprint(os.Stderr, "GetRowsWithColumnsTs requires 5 args\n")
flag.Usage()
}
argvalue0 := flag.Arg(1)
value0 := Hbase.Text(argvalue0)
arg1765 := flag.Arg(2)
mbTrans1766 := thrift.NewTMemoryBufferLen(len(arg1765))
defer mbTrans1766.Close()
_, err1767 := mbTrans1766.WriteString(arg1765)
if err1767 != nil {
Usage()
return
}
factory1768 := thrift.NewTSimpleJSONProtocolFactory()
jsProt1769 := factory1768.GetProtocol(mbTrans1766)
containerStruct1 := Hbase.NewGetRowsWithColumnsTsArgs()
err1770 := containerStruct1.ReadField2(jsProt1769)
if err1770 != nil {
Usage()
return
}
argvalue1 := containerStruct1.Rows
value1 := argvalue1
arg1771 := flag.Arg(3)
mbTrans1772 := thrift.NewTMemoryBufferLen(len(arg1771))
defer mbTrans1772.Close()
_, err1773 := mbTrans1772.WriteString(arg1771)
if err1773 != nil {
Usage()
return
}
factory1774 := thrift.NewTSimpleJSONProtocolFactory()
jsProt1775 := factory1774.GetProtocol(mbTrans1772)
containerStruct2 := Hbase.NewGetRowsWithColumnsTsArgs()
err1776 := containerStruct2.ReadField3(jsProt1775)
if err1776 != nil {
Usage()
return
}
argvalue2 := containerStruct2.Columns
value2 := argvalue2
argvalue3, err1777 := (strconv.ParseInt(flag.Arg(4), 10, 64))
if err1777 != nil {
Usage()
return
}
value3 := argvalue3
arg1778 := flag.Arg(5)
mbTrans1779 := thrift.NewTMemoryBufferLen(len(arg1778))
defer mbTrans1779.Close()
_, err1780 := mbTrans1779.WriteString(arg1778)
if err1780 != nil {
Usage()
return
}
factory1781 := thrift.NewTSimpleJSONProtocolFactory()
jsProt1782 := factory1781.GetProtocol(mbTrans1779)
containerStruct4 := Hbase.NewGetRowsWithColumnsTsArgs()
err1783 := containerStruct4.ReadField5(jsProt1782)
if err1783 != nil {
Usage()
return
}
argvalue4 := containerStruct4.Attributes
value4 := argvalue4
fmt.Print(client.GetRowsWithColumnsTs(value0, value1, value2, value3, value4))
fmt.Print("\n")
break
case "mutateRow":
if flag.NArg()-1 != 4 {
fmt.Fprint(os.Stderr, "MutateRow requires 4 args\n")
flag.Usage()
}
argvalue0 := flag.Arg(1)
value0 := Hbase.Text(argvalue0)
argvalue1 := flag.Arg(2)
value1 := Hbase.Text(argvalue1)
arg1786 := flag.Arg(3)
mbTrans1787 := thrift.NewTMemoryBufferLen(len(arg1786))
defer mbTrans1787.Close()
_, err1788 := mbTrans1787.WriteString(arg1786)
if err1788 != nil {
Usage()
return
}
factory1789 := thrift.NewTSimpleJSONProtocolFactory()
jsProt1790 := factory1789.GetProtocol(mbTrans1787)
containerStruct2 := Hbase.NewMutateRowArgs()
err1791 := containerStruct2.ReadField3(jsProt1790)
if err1791 != nil {
Usage()
return
}
argvalue2 := containerStruct2.Mutations
value2 := argvalue2
arg1792 := flag.Arg(4)
mbTrans1793 := thrift.NewTMemoryBufferLen(len(arg1792))
defer mbTrans1793.Close()
_, err1794 := mbTrans1793.WriteString(arg1792)
if err1794 != nil {
Usage()
return
}
factory1795 := thrift.NewTSimpleJSONProtocolFactory()
jsProt1796 := factory1795.GetProtocol(mbTrans1793)
containerStruct3 := Hbase.NewMutateRowArgs()
err1797 := containerStruct3.ReadField4(jsProt1796)
if err1797 != nil {
Usage()
return
}
argvalue3 := containerStruct3.Attributes
value3 := argvalue3
fmt.Print(client.MutateRow(value0, value1, value2, value3))
fmt.Print("\n")
break
case "mutateRowTs":
if flag.NArg()-1 != 5 {
fmt.Fprint(os.Stderr, "MutateRowTs requires 5 args\n")
flag.Usage()
}
argvalue0 := flag.Arg(1)
value0 := Hbase.Text(argvalue0)
argvalue1 := flag.Arg(2)
value1 := Hbase.Text(argvalue1)
arg1800 := flag.Arg(3)
mbTrans1801 := thrift.NewTMemoryBufferLen(len(arg1800))
defer mbTrans1801.Close()
_, err1802 := mbTrans1801.WriteString(arg1800)
if err1802 != nil {
Usage()
return
}
factory1803 := thrift.NewTSimpleJSONProtocolFactory()
jsProt1804 := factory1803.GetProtocol(mbTrans1801)
containerStruct2 := Hbase.NewMutateRowTsArgs()
err1805 := containerStruct2.ReadField3(jsProt1804)
if err1805 != nil {
Usage()
return
}
argvalue2 := containerStruct2.Mutations
value2 := argvalue2
argvalue3, err1806 := (strconv.ParseInt(flag.Arg(4), 10, 64))
if err1806 != nil {
Usage()
return
}
value3 := argvalue3
arg1807 := flag.Arg(5)
mbTrans1808 := thrift.NewTMemoryBufferLen(len(arg1807))
defer mbTrans1808.Close()
_, err1809 := mbTrans1808.WriteString(arg1807)
if err1809 != nil {
Usage()
return
}
factory1810 := thrift.NewTSimpleJSONProtocolFactory()
jsProt1811 := factory1810.GetProtocol(mbTrans1808)
containerStruct4 := Hbase.NewMutateRowTsArgs()
err1812 := containerStruct4.ReadField5(jsProt1811)
if err1812 != nil {
Usage()
return
}
argvalue4 := containerStruct4.Attributes
value4 := argvalue4
fmt.Print(client.MutateRowTs(value0, value1, value2, value3, value4))
fmt.Print("\n")
break
case "mutateRows":
if flag.NArg()-1 != 3 {
fmt.Fprint(os.Stderr, "MutateRows requires 3 args\n")
flag.Usage()
}
argvalue0 := flag.Arg(1)
value0 := Hbase.Text(argvalue0)
arg1814 := flag.Arg(2)
mbTrans1815 := thrift.NewTMemoryBufferLen(len(arg1814))
defer mbTrans1815.Close()
_, err1816 := mbTrans1815.WriteString(arg1814)
if err1816 != nil {
Usage()
return
}
factory1817 := thrift.NewTSimpleJSONProtocolFactory()
jsProt1818 := factory1817.GetProtocol(mbTrans1815)
containerStruct1 := Hbase.NewMutateRowsArgs()
err1819 := containerStruct1.ReadField2(jsProt1818)
if err1819 != nil {
Usage()
return
}
argvalue1 := containerStruct1.RowBatches
value1 := argvalue1
arg1820 := flag.Arg(3)
mbTrans1821 := thrift.NewTMemoryBufferLen(len(arg1820))
defer mbTrans1821.Close()
_, err1822 := mbTrans1821.WriteString(arg1820)
if err1822 != nil {
Usage()
return
}
factory1823 := thrift.NewTSimpleJSONProtocolFactory()
jsProt1824 := factory1823.GetProtocol(mbTrans1821)
containerStruct2 := Hbase.NewMutateRowsArgs()
err1825 := containerStruct2.ReadField3(jsProt1824)
if err1825 != nil {
Usage()
return
}
argvalue2 := containerStruct2.Attributes
value2 := argvalue2
fmt.Print(client.MutateRows(value0, value1, value2))
fmt.Print("\n")
break
case "mutateRowsTs":
if flag.NArg()-1 != 4 {
fmt.Fprint(os.Stderr, "MutateRowsTs requires 4 args\n")
flag.Usage()
}
argvalue0 := flag.Arg(1)
value0 := Hbase.Text(argvalue0)
arg1827 := flag.Arg(2)
mbTrans1828 := thrift.NewTMemoryBufferLen(len(arg1827))
defer mbTrans1828.Close()
_, err1829 := mbTrans1828.WriteString(arg1827)
if err1829 != nil {
Usage()
return
}
factory1830 := thrift.NewTSimpleJSONProtocolFactory()
jsProt1831 := factory1830.GetProtocol(mbTrans1828)
containerStruct1 := Hbase.NewMutateRowsTsArgs()
err1832 := containerStruct1.ReadField2(jsProt1831)
if err1832 != nil {
Usage()
return
}
argvalue1 := containerStruct1.RowBatches
value1 := argvalue1
argvalue2, err1833 := (strconv.ParseInt(flag.Arg(3), 10, 64))
if err1833 != nil {
Usage()
return
}
value2 := argvalue2
arg1834 := flag.Arg(4)
mbTrans1835 := thrift.NewTMemoryBufferLen(len(arg1834))
defer mbTrans1835.Close()
_, err1836 := mbTrans1835.WriteString(arg1834)
if err1836 != nil {
Usage()
return
}
factory1837 := thrift.NewTSimpleJSONProtocolFactory()
jsProt1838 := factory1837.GetProtocol(mbTrans1835)
containerStruct3 := Hbase.NewMutateRowsTsArgs()
err1839 := containerStruct3.ReadField4(jsProt1838)
if err1839 != nil {
Usage()
return
}
argvalue3 := containerStruct3.Attributes
value3 := argvalue3
fmt.Print(client.MutateRowsTs(value0, value1, value2, value3))
fmt.Print("\n")
break
case "atomicIncrement":
if flag.NArg()-1 != 4 {
fmt.Fprint(os.Stderr, "AtomicIncrement requires 4 args\n")
flag.Usage()
}
argvalue0 := flag.Arg(1)
value0 := Hbase.Text(argvalue0)
argvalue1 := flag.Arg(2)
value1 := Hbase.Text(argvalue1)
argvalue2 := flag.Arg(3)
value2 := Hbase.Text(argvalue2)
argvalue3, err1843 := (strconv.ParseInt(flag.Arg(4), 10, 64))
if err1843 != nil {
Usage()
return
}
value3 := argvalue3
fmt.Print(client.AtomicIncrement(value0, value1, value2, value3))
fmt.Print("\n")
break
case "deleteAll":
if flag.NArg()-1 != 4 {
fmt.Fprint(os.Stderr, "DeleteAll requires 4 args\n")
flag.Usage()
}
argvalue0 := flag.Arg(1)
value0 := Hbase.Text(argvalue0)
argvalue1 := flag.Arg(2)
value1 := Hbase.Text(argvalue1)
argvalue2 := flag.Arg(3)
value2 := Hbase.Text(argvalue2)
arg1847 := flag.Arg(4)
mbTrans1848 := thrift.NewTMemoryBufferLen(len(arg1847))
defer mbTrans1848.Close()
_, err1849 := mbTrans1848.WriteString(arg1847)
if err1849 != nil {
Usage()
return
}
factory1850 := thrift.NewTSimpleJSONProtocolFactory()
jsProt1851 := factory1850.GetProtocol(mbTrans1848)
containerStruct3 := Hbase.NewDeleteAllArgs()
err1852 := containerStruct3.ReadField4(jsProt1851)
if err1852 != nil {
Usage()
return
}
argvalue3 := containerStruct3.Attributes
value3 := argvalue3
fmt.Print(client.DeleteAll(value0, value1, value2, value3))
fmt.Print("\n")
break
case "deleteAllTs":
if flag.NArg()-1 != 5 {
fmt.Fprint(os.Stderr, "DeleteAllTs requires 5 args\n")
flag.Usage()
}
argvalue0 := flag.Arg(1)
value0 := Hbase.Text(argvalue0)
argvalue1 := flag.Arg(2)
value1 := Hbase.Text(argvalue1)
argvalue2 := flag.Arg(3)
value2 := Hbase.Text(argvalue2)
argvalue3, err1856 := (strconv.ParseInt(flag.Arg(4), 10, 64))
if err1856 != nil {
Usage()
return
}
value3 := argvalue3
arg1857 := flag.Arg(5)
mbTrans1858 := thrift.NewTMemoryBufferLen(len(arg1857))
defer mbTrans1858.Close()
_, err1859 := mbTrans1858.WriteString(arg1857)
if err1859 != nil {
Usage()
return
}
factory1860 := thrift.NewTSimpleJSONProtocolFactory()
jsProt1861 := factory1860.GetProtocol(mbTrans1858)
containerStruct4 := Hbase.NewDeleteAllTsArgs()
err1862 := containerStruct4.ReadField5(jsProt1861)
if err1862 != nil {
Usage()
return
}
argvalue4 := containerStruct4.Attributes
value4 := argvalue4
fmt.Print(client.DeleteAllTs(value0, value1, value2, value3, value4))
fmt.Print("\n")
break
case "deleteAllRow":
if flag.NArg()-1 != 3 {
fmt.Fprint(os.Stderr, "DeleteAllRow requires 3 args\n")
flag.Usage()
}
argvalue0 := flag.Arg(1)
value0 := Hbase.Text(argvalue0)
argvalue1 := flag.Arg(2)
value1 := Hbase.Text(argvalue1)
arg1865 := flag.Arg(3)
mbTrans1866 := thrift.NewTMemoryBufferLen(len(arg1865))
defer mbTrans1866.Close()
_, err1867 := mbTrans1866.WriteString(arg1865)
if err1867 != nil {
Usage()
return
}
factory1868 := thrift.NewTSimpleJSONProtocolFactory()
jsProt1869 := factory1868.GetProtocol(mbTrans1866)
containerStruct2 := Hbase.NewDeleteAllRowArgs()
err1870 := containerStruct2.ReadField3(jsProt1869)
if err1870 != nil {
Usage()
return
}
argvalue2 := containerStruct2.Attributes
value2 := argvalue2
fmt.Print(client.DeleteAllRow(value0, value1, value2))
fmt.Print("\n")
break
case "increment":
if flag.NArg()-1 != 1 {
fmt.Fprint(os.Stderr, "Increment requires 1 args\n")
flag.Usage()
}
arg1871 := flag.Arg(1)
mbTrans1872 := thrift.NewTMemoryBufferLen(len(arg1871))
defer mbTrans1872.Close()
_, err1873 := mbTrans1872.WriteString(arg1871)
if err1873 != nil {
Usage()
return
}
factory1874 := thrift.NewTSimpleJSONProtocolFactory()
jsProt1875 := factory1874.GetProtocol(mbTrans1872)
argvalue0 := Hbase.NewTIncrement()
err1876 := argvalue0.Read(jsProt1875)
if err1876 != nil {
Usage()
return
}
value0 := argvalue0
fmt.Print(client.Increment(value0))
fmt.Print("\n")
break
case "incrementRows":
if flag.NArg()-1 != 1 {
fmt.Fprint(os.Stderr, "IncrementRows requires 1 args\n")
flag.Usage()
}
arg1877 := flag.Arg(1)
mbTrans1878 := thrift.NewTMemoryBufferLen(len(arg1877))
defer mbTrans1878.Close()
_, err1879 := mbTrans1878.WriteString(arg1877)
if err1879 != nil {
Usage()
return
}
factory1880 := thrift.NewTSimpleJSONProtocolFactory()
jsProt1881 := factory1880.GetProtocol(mbTrans1878)
containerStruct0 := Hbase.NewIncrementRowsArgs()
err1882 := containerStruct0.ReadField1(jsProt1881)
if err1882 != nil {
Usage()
return
}
argvalue0 := containerStruct0.Increments
value0 := argvalue0
fmt.Print(client.IncrementRows(value0))
fmt.Print("\n")
break
case "deleteAllRowTs":
if flag.NArg()-1 != 4 {
fmt.Fprint(os.Stderr, "DeleteAllRowTs requires 4 args\n")
flag.Usage()
}
argvalue0 := flag.Arg(1)
value0 := Hbase.Text(argvalue0)
argvalue1 := flag.Arg(2)
value1 := Hbase.Text(argvalue1)
argvalue2, err1885 := (strconv.ParseInt(flag.Arg(3), 10, 64))
if err1885 != nil {
Usage()
return
}
value2 := argvalue2
arg1886 := flag.Arg(4)
mbTrans1887 := thrift.NewTMemoryBufferLen(len(arg1886))
defer mbTrans1887.Close()
_, err1888 := mbTrans1887.WriteString(arg1886)
if err1888 != nil {
Usage()
return
}
factory1889 := thrift.NewTSimpleJSONProtocolFactory()
jsProt1890 := factory1889.GetProtocol(mbTrans1887)
containerStruct3 := Hbase.NewDeleteAllRowTsArgs()
err1891 := containerStruct3.ReadField4(jsProt1890)
if err1891 != nil {
Usage()
return
}
argvalue3 := containerStruct3.Attributes
value3 := argvalue3
fmt.Print(client.DeleteAllRowTs(value0, value1, value2, value3))
fmt.Print("\n")
break
case "scannerOpenWithScan":
if flag.NArg()-1 != 3 {
fmt.Fprint(os.Stderr, "ScannerOpenWithScan requires 3 args\n")
flag.Usage()
}
argvalue0 := flag.Arg(1)
value0 := Hbase.Text(argvalue0)
arg1893 := flag.Arg(2)
mbTrans1894 := thrift.NewTMemoryBufferLen(len(arg1893))
defer mbTrans1894.Close()
_, err1895 := mbTrans1894.WriteString(arg1893)
if err1895 != nil {
Usage()
return
}
factory1896 := thrift.NewTSimpleJSONProtocolFactory()
jsProt1897 := factory1896.GetProtocol(mbTrans1894)
argvalue1 := Hbase.NewTScan()
err1898 := argvalue1.Read(jsProt1897)
if err1898 != nil {
Usage()
return
}
value1 := argvalue1
arg1899 := flag.Arg(3)
mbTrans1900 := thrift.NewTMemoryBufferLen(len(arg1899))
defer mbTrans1900.Close()
_, err1901 := mbTrans1900.WriteString(arg1899)
if err1901 != nil {
Usage()
return
}
factory1902 := thrift.NewTSimpleJSONProtocolFactory()
jsProt1903 := factory1902.GetProtocol(mbTrans1900)
containerStruct2 := Hbase.NewScannerOpenWithScanArgs()
err1904 := containerStruct2.ReadField3(jsProt1903)
if err1904 != nil {
Usage()
return
}
argvalue2 := containerStruct2.Attributes
value2 := argvalue2
fmt.Print(client.ScannerOpenWithScan(value0, value1, value2))
fmt.Print("\n")
break
case "scannerOpen":
if flag.NArg()-1 != 4 {
fmt.Fprint(os.Stderr, "ScannerOpen requires 4 args\n")
flag.Usage()
}
argvalue0 := flag.Arg(1)
value0 := Hbase.Text(argvalue0)
argvalue1 := flag.Arg(2)
value1 := Hbase.Text(argvalue1)
arg1907 := flag.Arg(3)
mbTrans1908 := thrift.NewTMemoryBufferLen(len(arg1907))
defer mbTrans1908.Close()
_, err1909 := mbTrans1908.WriteString(arg1907)
if err1909 != nil {
Usage()
return
}
factory1910 := thrift.NewTSimpleJSONProtocolFactory()
jsProt1911 := factory1910.GetProtocol(mbTrans1908)
containerStruct2 := Hbase.NewScannerOpenArgs()
err1912 := containerStruct2.ReadField3(jsProt1911)
if err1912 != nil {
Usage()
return
}
argvalue2 := containerStruct2.Columns
value2 := argvalue2
arg1913 := flag.Arg(4)
mbTrans1914 := thrift.NewTMemoryBufferLen(len(arg1913))
defer mbTrans1914.Close()
_, err1915 := mbTrans1914.WriteString(arg1913)
if err1915 != nil {
Usage()
return
}
factory1916 := thrift.NewTSimpleJSONProtocolFactory()
jsProt1917 := factory1916.GetProtocol(mbTrans1914)
containerStruct3 := Hbase.NewScannerOpenArgs()
err1918 := containerStruct3.ReadField4(jsProt1917)
if err1918 != nil {
Usage()
return
}
argvalue3 := containerStruct3.Attributes
value3 := argvalue3
fmt.Print(client.ScannerOpen(value0, value1, value2, value3))
fmt.Print("\n")
break
case "scannerOpenWithStop":
if flag.NArg()-1 != 5 {
fmt.Fprint(os.Stderr, "ScannerOpenWithStop requires 5 args\n")
flag.Usage()
}
argvalue0 := flag.Arg(1)
value0 := Hbase.Text(argvalue0)
argvalue1 := flag.Arg(2)
value1 := Hbase.Text(argvalue1)
argvalue2 := flag.Arg(3)
value2 := Hbase.Text(argvalue2)
arg1922 := flag.Arg(4)
mbTrans1923 := thrift.NewTMemoryBufferLen(len(arg1922))
defer mbTrans1923.Close()
_, err1924 := mbTrans1923.WriteString(arg1922)
if err1924 != nil {
Usage()
return
}
factory1925 := thrift.NewTSimpleJSONProtocolFactory()
jsProt1926 := factory1925.GetProtocol(mbTrans1923)
containerStruct3 := Hbase.NewScannerOpenWithStopArgs()
err1927 := containerStruct3.ReadField4(jsProt1926)
if err1927 != nil {
Usage()
return
}
argvalue3 := containerStruct3.Columns
value3 := argvalue3
arg1928 := flag.Arg(5)
mbTrans1929 := thrift.NewTMemoryBufferLen(len(arg1928))
defer mbTrans1929.Close()
_, err1930 := mbTrans1929.WriteString(arg1928)
if err1930 != nil {
Usage()
return
}
factory1931 := thrift.NewTSimpleJSONProtocolFactory()
jsProt1932 := factory1931.GetProtocol(mbTrans1929)
containerStruct4 := Hbase.NewScannerOpenWithStopArgs()
err1933 := containerStruct4.ReadField5(jsProt1932)
if err1933 != nil {
Usage()
return
}
argvalue4 := containerStruct4.Attributes
value4 := argvalue4
fmt.Print(client.ScannerOpenWithStop(value0, value1, value2, value3, value4))
fmt.Print("\n")
break
case "scannerOpenWithPrefix":
if flag.NArg()-1 != 4 {
fmt.Fprint(os.Stderr, "ScannerOpenWithPrefix requires 4 args\n")
flag.Usage()
}
argvalue0 := flag.Arg(1)
value0 := Hbase.Text(argvalue0)
argvalue1 := flag.Arg(2)
value1 := Hbase.Text(argvalue1)
arg1936 := flag.Arg(3)
mbTrans1937 := thrift.NewTMemoryBufferLen(len(arg1936))
defer mbTrans1937.Close()
_, err1938 := mbTrans1937.WriteString(arg1936)
if err1938 != nil {
Usage()
return
}
factory1939 := thrift.NewTSimpleJSONProtocolFactory()
jsProt1940 := factory1939.GetProtocol(mbTrans1937)
containerStruct2 := Hbase.NewScannerOpenWithPrefixArgs()
err1941 := containerStruct2.ReadField3(jsProt1940)
if err1941 != nil {
Usage()
return
}
argvalue2 := containerStruct2.Columns
value2 := argvalue2
arg1942 := flag.Arg(4)
mbTrans1943 := thrift.NewTMemoryBufferLen(len(arg1942))
defer mbTrans1943.Close()
_, err1944 := mbTrans1943.WriteString(arg1942)
if err1944 != nil {
Usage()
return
}
factory1945 := thrift.NewTSimpleJSONProtocolFactory()
jsProt1946 := factory1945.GetProtocol(mbTrans1943)
containerStruct3 := Hbase.NewScannerOpenWithPrefixArgs()
err1947 := containerStruct3.ReadField4(jsProt1946)
if err1947 != nil {
Usage()
return
}
argvalue3 := containerStruct3.Attributes
value3 := argvalue3
fmt.Print(client.ScannerOpenWithPrefix(value0, value1, value2, value3))
fmt.Print("\n")
break
case "scannerOpenTs":
if flag.NArg()-1 != 5 {
fmt.Fprint(os.Stderr, "ScannerOpenTs requires 5 args\n")
flag.Usage()
}
argvalue0 := flag.Arg(1)
value0 := Hbase.Text(argvalue0)
argvalue1 := flag.Arg(2)
value1 := Hbase.Text(argvalue1)
arg1950 := flag.Arg(3)
mbTrans1951 := thrift.NewTMemoryBufferLen(len(arg1950))
defer mbTrans1951.Close()
_, err1952 := mbTrans1951.WriteString(arg1950)
if err1952 != nil {
Usage()
return
}
factory1953 := thrift.NewTSimpleJSONProtocolFactory()
jsProt1954 := factory1953.GetProtocol(mbTrans1951)
containerStruct2 := Hbase.NewScannerOpenTsArgs()
err1955 := containerStruct2.ReadField3(jsProt1954)
if err1955 != nil {
Usage()
return
}
argvalue2 := containerStruct2.Columns
value2 := argvalue2
argvalue3, err1956 := (strconv.ParseInt(flag.Arg(4), 10, 64))
if err1956 != nil {
Usage()
return
}
value3 := argvalue3
arg1957 := flag.Arg(5)
mbTrans1958 := thrift.NewTMemoryBufferLen(len(arg1957))
defer mbTrans1958.Close()
_, err1959 := mbTrans1958.WriteString(arg1957)
if err1959 != nil {
Usage()
return
}
factory1960 := thrift.NewTSimpleJSONProtocolFactory()
jsProt1961 := factory1960.GetProtocol(mbTrans1958)
containerStruct4 := Hbase.NewScannerOpenTsArgs()
err1962 := containerStruct4.ReadField5(jsProt1961)
if err1962 != nil {
Usage()
return
}
argvalue4 := containerStruct4.Attributes
value4 := argvalue4
fmt.Print(client.ScannerOpenTs(value0, value1, value2, value3, value4))
fmt.Print("\n")
break
case "scannerOpenWithStopTs":
if flag.NArg()-1 != 6 {
fmt.Fprint(os.Stderr, "ScannerOpenWithStopTs requires 6 args\n")
flag.Usage()
}
argvalue0 := flag.Arg(1)
value0 := Hbase.Text(argvalue0)
argvalue1 := flag.Arg(2)
value1 := Hbase.Text(argvalue1)
argvalue2 := flag.Arg(3)
value2 := Hbase.Text(argvalue2)
arg1966 := flag.Arg(4)
mbTrans1967 := thrift.NewTMemoryBufferLen(len(arg1966))
defer mbTrans1967.Close()
_, err1968 := mbTrans1967.WriteString(arg1966)
if err1968 != nil {
Usage()
return
}
factory1969 := thrift.NewTSimpleJSONProtocolFactory()
jsProt1970 := factory1969.GetProtocol(mbTrans1967)
containerStruct3 := Hbase.NewScannerOpenWithStopTsArgs()
err1971 := containerStruct3.ReadField4(jsProt1970)
if err1971 != nil {
Usage()
return
}
argvalue3 := containerStruct3.Columns
value3 := argvalue3
argvalue4, err1972 := (strconv.ParseInt(flag.Arg(5), 10, 64))
if err1972 != nil {
Usage()
return
}
value4 := argvalue4
arg1973 := flag.Arg(6)
mbTrans1974 := thrift.NewTMemoryBufferLen(len(arg1973))
defer mbTrans1974.Close()
_, err1975 := mbTrans1974.WriteString(arg1973)
if err1975 != nil {
Usage()
return
}
factory1976 := thrift.NewTSimpleJSONProtocolFactory()
jsProt1977 := factory1976.GetProtocol(mbTrans1974)
containerStruct5 := Hbase.NewScannerOpenWithStopTsArgs()
err1978 := containerStruct5.ReadField6(jsProt1977)
if err1978 != nil {
Usage()
return
}
argvalue5 := containerStruct5.Attributes
value5 := argvalue5
fmt.Print(client.ScannerOpenWithStopTs(value0, value1, value2, value3, value4, value5))
fmt.Print("\n")
break
case "scannerGet":
if flag.NArg()-1 != 1 {
fmt.Fprint(os.Stderr, "ScannerGet requires 1 args\n")
flag.Usage()
}
tmp0, err1979 := (strconv.Atoi(flag.Arg(1)))
if err1979 != nil {
Usage()
return
}
argvalue0 := int32(tmp0)
value0 := Hbase.ScannerID(argvalue0)
fmt.Print(client.ScannerGet(value0))
fmt.Print("\n")
break
case "scannerGetList":
if flag.NArg()-1 != 2 {
fmt.Fprint(os.Stderr, "ScannerGetList requires 2 args\n")
flag.Usage()
}
tmp0, err1980 := (strconv.Atoi(flag.Arg(1)))
if err1980 != nil {
Usage()
return
}
argvalue0 := int32(tmp0)
value0 := Hbase.ScannerID(argvalue0)
tmp1, err1981 := (strconv.Atoi(flag.Arg(2)))
if err1981 != nil {
Usage()
return
}
argvalue1 := int32(tmp1)
value1 := argvalue1
fmt.Print(client.ScannerGetList(value0, value1))
fmt.Print("\n")
break
case "scannerClose":
if flag.NArg()-1 != 1 {
fmt.Fprint(os.Stderr, "ScannerClose requires 1 args\n")
flag.Usage()
}
tmp0, err1982 := (strconv.Atoi(flag.Arg(1)))
if err1982 != nil {
Usage()
return
}
argvalue0 := int32(tmp0)
value0 := Hbase.ScannerID(argvalue0)
fmt.Print(client.ScannerClose(value0))
fmt.Print("\n")
break
case "getRowOrBefore":
if flag.NArg()-1 != 3 {
fmt.Fprint(os.Stderr, "GetRowOrBefore requires 3 args\n")
flag.Usage()
}
argvalue0 := flag.Arg(1)
value0 := Hbase.Text(argvalue0)
argvalue1 := flag.Arg(2)
value1 := Hbase.Text(argvalue1)
argvalue2 := flag.Arg(3)
value2 := Hbase.Text(argvalue2)
fmt.Print(client.GetRowOrBefore(value0, value1, value2))
fmt.Print("\n")
break
case "getRegionInfo":
if flag.NArg()-1 != 1 {
fmt.Fprint(os.Stderr, "GetRegionInfo requires 1 args\n")
flag.Usage()
}
argvalue0 := flag.Arg(1)
value0 := Hbase.Text(argvalue0)
fmt.Print(client.GetRegionInfo(value0))
fmt.Print("\n")
break
case "":
Usage()
break
default:
fmt.Fprint(os.Stderr, "Invalid function ", cmd, "\n")
}
}