func toHbaseTScan(scan *TScan) *Hbase.TScan { if scan == nil { return nil } if scan.FilterString == "" { return &Hbase.TScan{ StartRow: Hbase.Text(scan.StartRow), StopRow: Hbase.Text(scan.StopRow), Timestamp: scan.Timestamp, Columns: toHbaseTextList(scan.Columns), Caching: scan.Caching, FilterString: nil, } } return &Hbase.TScan{ StartRow: Hbase.Text(scan.StartRow), StopRow: Hbase.Text(scan.StopRow), Timestamp: scan.Timestamp, Columns: toHbaseTextList(scan.Columns), Caching: scan.Caching, FilterString: Hbase.Text(scan.FilterString), } }
func NewTIncrement(table string, row []byte, column string, ammount int64) *Hbase.TIncrement { return &Hbase.TIncrement{ Table: Hbase.Text(table), Row: Hbase.Text(row), Column: Hbase.Text(column), Ammount: ammount, } }
/** * Get the row just before the specified one. * * @return value for specified row/column * * Parameters: * - TableName: name of table * - Row: row key * - Family: column name */ func (client *HClient) GetRowOrBefore(tableName string, row string, family string) (data []*Hbase.TCell, err error) { ret, io, e1 := client.hbase.GetRowOrBefore(Hbase.Text(tableName), Hbase.Text(row), Hbase.Text(family)) if err = checkHbaseError(io, e1); err != nil { return } data = ret return }
/** * Get a scanner on the current table starting and stopping at the * specified rows. ending at the last row in the table. Return the * specified columns. Only values with the specified timestamp are * returned. * * @return scanner id to be used with other scanner procedures * * Parameters: * - TableName: name of table * - StartRow: Starting row in table to scan. * Send "" (empty string) to start at the first row. * - StopRow: row to stop scanning on. This row is *not* included in the * scanner's results * - Columns: columns to scan. If column name is a column family, all * columns of the specified column family are returned. It's also possible * to pass a regex in the column qualifier. * - Timestamp: timestamp * - Attributes: Scan attributes */ func (client *HClient) ScannerOpenWithStopTs(tableName string, startRow []byte, stopRow []byte, columns []string, timestamp int64, attributes map[string]string) (id int32, err error) { ret, io, e1 := client.hbase.ScannerOpenWithStopTs(Hbase.Text(tableName), Hbase.Text(startRow), Hbase.Text(stopRow), toHbaseTextList(columns), timestamp, toHbaseTextMap(attributes)) if err = checkHbaseError(io, e1); err != nil { return } id = int32(ret) return }
/** * Get the specified number of versions for the specified table, * row, and column. Only versions less than or equal to the specified * timestamp will be returned. * * @return list of cells for specified row/column * * Parameters: * - TableName: name of table * - Row: row key * - Column: column name * - Timestamp: timestamp * - NumVersions: number of versions to retrieve * - Attributes: Get attributes */ func (client *HClient) GetVerTs(tableName string, row []byte, column string, timestamp int64, numVersions int32, attributes map[string]string) (data []*Hbase.TCell, err error) { ret, io, e1 := client.hbase.GetVerTs(Hbase.Text(tableName), Hbase.Text(row), Hbase.Text(column), timestamp, numVersions, toHbaseTextMap(attributes)) if err = checkHbaseError(io, e1); err != nil { return } data = ret return }
/** * Atomically increment the column value specified. Returns the next value post increment. * * Parameters: * - TableName: name of table * - Row: row to increment * - Column: name of column * - Value: amount to increment by */ func (client *HClient) AtomicIncrement(tableName string, row []byte, column string, value int64) (v int64, err error) { ret, io, ia, e1 := client.hbase.AtomicIncrement(Hbase.Text(tableName), Hbase.Text(row), Hbase.Text(column), value) if err = checkHbaseArgError(io, ia, e1); err != nil { return } v = ret return }
/** * Get the specified columns for the specified table and row at the specified * timestamp. Returns an empty list if the row does not exist. * * @return TRowResult containing the row and map of columns to TCells * * Parameters: * - TableName: name of table * - Row: row key * - Columns: List of columns to return, null for all columns * - Timestamp * - Attributes: Get attributes */ func (client *HClient) GetRowWithColumnsTs(tableName string, row []byte, columns []string, timestamp int64, attributes map[string]string) (data []*Hbase.TRowResult, err error) { ret, io, e1 := client.hbase.GetRowWithColumnsTs(Hbase.Text(tableName), Hbase.Text(row), toHbaseTextList(columns), timestamp, toHbaseTextMap(attributes)) if err = checkHbaseError(io, e1); err != nil { return } data = ret return }
func NewMutation(column string, value []byte) *Hbase.Mutation { return &Hbase.Mutation{ IsDelete: false, WriteToWAL: true, Column: Hbase.Text(column), Value: Hbase.Text(value), } }
/** * Open a scanner for a given prefix. That is all rows will have the specified * prefix. No other rows will be returned. * * @return scanner id to use with other scanner calls * * Parameters: * - TableName: name of table * - StartAndPrefix: the prefix (and thus start row) of the keys you want * - Columns: the columns you want returned * - Attributes: Scan attributes */ func (client *HClient) ScannerOpenWithPrefix(tableName string, startAndPrefix []byte, columns []string, attributes map[string]string) (id int32, err error) { ret, io, e1 := client.hbase.ScannerOpenWithPrefix(Hbase.Text(tableName), Hbase.Text(startAndPrefix), toHbaseTextList(columns), toHbaseTextMap(attributes)) if err = checkHbaseError(io, e1); err != nil { return } id = int32(ret) return }
/** * Get all the data for the specified table and row at the latest * timestamp. Returns an empty list if the row does not exist. * * @return TRowResult containing the row and map of columns to TCells * * Parameters: * - TableName: name of table * - Row: row key * - Attributes: Get attributes */ func (client *HClient) GetRow(tableName string, row []byte, attributes map[string]string) (data []*Hbase.TRowResult, err error) { ret, io, e1 := client.hbase.GetRow(Hbase.Text(tableName), Hbase.Text(row), toHbaseTextMap(attributes)) if err = checkHbaseError(io, e1); err != nil { return } data = ret return }
func fromMapStr(data map[string]string) thrift.TMap { var m thrift.TMap if data != nil { m = thrift.NewTMap(thrift.STRING, thrift.STRING, len(data)) for k, v := range data { m.Set(Hbase.Text(k), Hbase.Text(v)) } } return m }
/** * Get the row just before the specified one. * * @return value for specified row/column * * Parameters: * - TableName: name of table * - Row: row key * - Family: column name */ func (client *HClient) GetRowOrBefore(tableName string, row string, family string) (data []*TCell, err error) { if err = client.Open(); err != nil { return } ret, io, e1 := client.thriftClient.GetRowOrBefore(Hbase.Text(tableName), Hbase.Text(row), Hbase.Text(family)) if err = checkHbaseError(io, e1); err != nil { return } data = toListCell(ret) return }
/** * Get the specified columns for the specified table and row at the specified * timestamp. Returns an empty list if the row does not exist. * * @return TRowResult containing the row and map of columns to TCells * * Parameters: * - TableName: name of table * - Row: row key * - Columns: List of columns to return, null for all columns * - Timestamp * - Attributes: Get attributes */ func (client *HClient) GetRowWithColumnsTs(tableName string, row string, columns []string, timestamp int64, attributes map[string]string) (data []*TRowResult, err error) { if err = client.Open(); err != nil { return } ret, io, e1 := client.thriftClient.GetRowWithColumnsTs(Hbase.Text(tableName), Hbase.Text(row), fromListStr(columns), timestamp, fromMapStr(attributes)) if err = checkHbaseError(io, e1); err != nil { return } data = toListRowResult(ret) return }
/** * Get all the data for the specified table and row at the latest * timestamp. Returns an empty list if the row does not exist. * * @return TRowResult containing the row and map of columns to TCells * * Parameters: * - TableName: name of table * - Row: row key * - Attributes: Get attributes */ func (client *HClient) GetRow(tableName string, row string, attributes map[string]string) (data []*TRowResult, err error) { if err = client.Open(); err != nil { return } ret, io, e1 := client.thriftClient.GetRow(Hbase.Text(tableName), Hbase.Text(row), fromMapStr(attributes)) if err = checkHbaseError(io, e1); err != nil { return } data = toListRowResult(ret) return }
/** * Get the specified number of versions for the specified table, * row, and column. Only versions less than or equal to the specified * timestamp will be returned. * * @return list of cells for specified row/column * * Parameters: * - TableName: name of table * - Row: row key * - Column: column name * - Timestamp: timestamp * - NumVersions: number of versions to retrieve * - Attributes: Get attributes */ func (client *HClient) GetVerTs(tableName string, row string, column string, timestamp int64, numVersions int32, attributes map[string]string) (data []*TCell, err error) { if err = client.Open(); err != nil { return } ret, io, e1 := client.thriftClient.GetVerTs(Hbase.Text(tableName), Hbase.Text(row), Hbase.Text(column), timestamp, numVersions, fromMapStr(attributes)) if err = checkHbaseError(io, e1); err != nil { return } data = toListCell(ret) return }
/** * Deletes a table * * @throws IOError if table doesn't exist on server or there was some other * problem * * Parameters: * - TableName: name of table to delete */ func (client *HClient) DeleteTable(tableName string) (err error) { if err = client.Open(); err != nil { return } return checkHbaseError(client.thriftClient.DeleteTable(Hbase.Text(tableName))) }
/** * List all the column families assoicated with a table. * * @return list of column family descriptors * * Parameters: * - TableName: table name */ func (client *HClient) GetColumnDescriptors(tableName string) (columns map[string]*ColumnDescriptor, err error) { ret, io, e1 := client.hbase.GetColumnDescriptors(Hbase.Text(tableName)) if err = checkHbaseError(io, e1); err != nil { return } columns = toColMap(ret) return }
/** * Create a table with the specified column families. The name * field for each ColumnDescriptor must be set and must end in a * colon (:). All other fields are optional and will get default * values if not explicitly specified. * * @throws IllegalArgument if an input parameter is invalid * * @throws AlreadyExists if the table name already exists * * Parameters: * - TableName: name of table to create * - ColumnFamilies: list of column family descriptors */ func (client *HClient) CreateTable(tableName string, columnFamilies []*ColumnDescriptor) (exists bool, err error) { columns := toHbaseColList(columnFamilies) io, ia, ex, e1 := client.hbase.CreateTable(Hbase.Text(tableName), columns) if err = checkHbaseArgError(io, ia, e1); err != nil { return } exists = (ex != nil) return }
/** * List the regions associated with a table. * * @return list of region descriptors * * Parameters: * - TableName: table name */ func (client *HClient) GetTableRegions(tableName string) (regions []*TRegionInfo, err error) { ret, io, e1 := client.hbase.GetTableRegions(Hbase.Text(tableName)) if err = checkHbaseError(io, e1); err != nil { return } regions = toRegionList(ret) return }
/** * Get the regininfo for the specified row. It scans * the metatable to find region's start and end keys. * * @return value for specified row/column * * Parameters: * - Row: row key */ func (client *HClient) GetRegionInfo(row string) (region *TRegionInfo, err error) { ret, io, e1 := client.hbase.GetRegionInfo(Hbase.Text(row)) if err = checkHbaseError(io, e1); err != nil { return } region = toRegion(ret) return }
/** * Get a scanner on the current table, using the Scan instance * for the scan parameters. * * Parameters: * - TableName: name of table * - Scan: Scan instance * - Attributes: Scan attributes */ func (client *HClient) ScannerOpenWithScan(tableName string, scan *TScan, attributes map[string]string) (id int32, err error) { ret, io, e1 := client.hbase.ScannerOpenWithScan(Hbase.Text(tableName), toHbaseTScan(scan), toHbaseTextMap(attributes)) if err = checkHbaseError(io, e1); err != nil { return } id = int32(ret) return }
/** * Create a table with the specified column families. The name * field for each ColumnDescriptor must be set and must end in a * colon (:). All other fields are optional and will get default * values if not explicitly specified. * * @throws IllegalArgument if an input parameter is invalid * * @throws AlreadyExists if the table name already exists * * Parameters: * - TableName: name of table to create * - ColumnFamilies: list of column family descriptors */ func (client *HClient) CreateTable(tableName string, columnFamilies []*ColumnDescriptor) (exist *AlreadyExists, err error) { if err = client.Open(); err != nil { return } columns := fromColumns(columnFamilies) io, ia, ex, e1 := client.thriftClient.CreateTable(Hbase.Text(tableName), columns) err = checkHbaseArgError(io, ia, e1) exist = toAlreadyExists(ex) return }
func toHbaseTextListFromByte(list [][]byte) []Hbase.Text { if list == nil { return nil } l := len(list) data := make([]Hbase.Text, l) for i := 0; i < l; i++ { data[i] = Hbase.Text(list[i]) } return data }
func toHbaseTextMap(source map[string]string) map[string]Hbase.Text { if source == nil { return nil } data := make(map[string]Hbase.Text, len(source)) for k, v := range source { data[k] = Hbase.Text(v) } return data }
/** * Get the specified columns for the specified table and rows at the latest * timestamp. Returns an empty list if no rows exist. * * @return TRowResult containing the rows and map of columns to TCells * * Parameters: * - TableName: name of table * - Rows: row keys * - Columns: List of columns to return, null for all columns * - Attributes: Get attributes */ func (client *HClient) GetRowsWithColumns(tableName string, rows [][]byte, columns []string, attributes map[string]string) (data []*Hbase.TRowResult, err error) { if err = client.Open(); err != nil { return } ret, io, e1 := client.hbase.GetRowsWithColumns(Hbase.Text(tableName), toHbaseTextListFromByte(rows), toHbaseTextList(columns), toHbaseTextMap(attributes)) if err = checkHbaseError(io, e1); err != nil { return } data = ret return }
func fromListStr(list []string) thrift.TList { if list == nil { return nil } l := len(list) data := thrift.NewTList(thrift.STRING, l) for i := 0; i < l; i++ { //data.Set(i, Hbase.Text(list[i])) data.Push(Hbase.Text(list[i])) } return data }
func toHbaseColumn(col *ColumnDescriptor) *Hbase.ColumnDescriptor { return &Hbase.ColumnDescriptor{ Name: Hbase.Text(col.Name), MaxVersions: col.MaxVersions, Compression: col.Compression, InMemory: col.InMemory, BloomFilterType: col.BloomFilterType, BloomFilterVectorSize: col.BloomFilterVectorSize, BloomFilterNbHashes: col.BloomFilterNbHashes, BlockCacheEnabled: col.BlockCacheEnabled, TimeToLive: col.TimeToLive, } }
func fromColumns(columnFamilies []*ColumnDescriptor) thrift.TList { l := len(columnFamilies) columns := thrift.NewTListDefault() for i := 0; i < l; i++ { col := columnFamilies[i] hbaseColumn := &Hbase.ColumnDescriptor{ Name: Hbase.Text(col.Name), MaxVersions: col.MaxVersions, Compression: col.Compression, InMemory: col.InMemory, BloomFilterType: col.BloomFilterType, BloomFilterVectorSize: col.BloomFilterVectorSize, BloomFilterNbHashes: col.BloomFilterNbHashes, BlockCacheEnabled: col.BlockCacheEnabled, TimeToLive: col.TimeToLive, } columns.Push(hbaseColumn) } return columns }
/** * Completely delete the row's cells marked with a timestamp * equal-to or older than the passed timestamp. * * Parameters: * - TableName: name of table * - Row: key of the row to be completely deleted. * - Timestamp: timestamp * - Attributes: Delete attributes */ func (client *HClient) DeleteAllRowTs(tableName string, row []byte, timestamp int64, attributes map[string]string) error { return checkHbaseError(client.hbase.DeleteAllRowTs(Hbase.Text(tableName), Hbase.Text(row), timestamp, toHbaseTextMap(attributes))) }
/** * Delete all cells that match the passed row and column. * * Parameters: * - TableName: name of table * - Row: Row to update * - Column: name of column whose value is to be deleted * - Attributes: Delete attributes */ func (client *HClient) DeleteAll(tableName string, row []byte, column string, attributes map[string]string) error { return checkHbaseError(client.hbase.DeleteAll(Hbase.Text(tableName), Hbase.Text(row), Hbase.Text(column), toHbaseTextMap(attributes))) }