github.com/insionng/yougam@v0.0.0-20170714101924-2bc18d833463/libraries/pingcap/go-hbase/column.go (about)

     1  package hbase
     2  
     3  import (
     4  	"bytes"
     5  	"fmt"
     6  	"io"
     7  
     8  	"github.com/insionng/yougam/libraries/juju/errors"
     9  	"github.com/insionng/yougam/libraries/pingcap/go-hbase/iohelper"
    10  )
    11  
    12  type Column struct {
    13  	Family []byte
    14  	Qual   []byte
    15  }
    16  
    17  func NewColumn(family, qual []byte) *Column {
    18  	return &Column{
    19  		Family: family,
    20  		Qual:   qual,
    21  	}
    22  }
    23  
    24  func encode(parts ...[]byte) ([]byte, error) {
    25  	buf := &bytes.Buffer{}
    26  	for _, p := range parts {
    27  		err := iohelper.WriteVarBytes(buf, p)
    28  		if err != nil {
    29  			return nil, errors.Trace(err)
    30  		}
    31  	}
    32  	return buf.Bytes(), nil
    33  }
    34  
    35  func decode(encoded []byte) ([][]byte, error) {
    36  	var ret [][]byte
    37  	buf := bytes.NewBuffer(encoded)
    38  	for {
    39  		b, err := iohelper.ReadVarBytes(buf)
    40  		if len(b) == 0 || (err != nil && ErrorEqual(err, io.EOF)) {
    41  			break
    42  		}
    43  		ret = append(ret, b)
    44  	}
    45  	return ret, nil
    46  }
    47  
    48  func (c *Column) Write(w io.Writer) error {
    49  	err := iohelper.WriteVarBytes(w, c.Family)
    50  	if err != nil {
    51  		return errors.Trace(err)
    52  	}
    53  
    54  	err = iohelper.WriteVarBytes(w, c.Qual)
    55  	if err != nil {
    56  		return errors.Trace(err)
    57  	}
    58  
    59  	return nil
    60  }
    61  
    62  func (c *Column) String() string {
    63  	b, err := encode(c.Family, c.Qual)
    64  	if err != nil {
    65  		return fmt.Sprintf("invalid column - %v", err)
    66  	}
    67  	return string(b)
    68  }
    69  
    70  func (c *Column) ParseFromString(s string) error {
    71  	pairs, err := decode([]byte(s))
    72  	if err != nil {
    73  		return errors.Trace(err)
    74  	}
    75  
    76  	c.Family = pairs[0]
    77  	c.Qual = pairs[1]
    78  	return nil
    79  }
    80  
    81  type ColumnCoordinate struct {
    82  	Table []byte
    83  	Row   []byte
    84  	Column
    85  }
    86  
    87  func NewColumnCoordinate(table, row, family, qual []byte) *ColumnCoordinate {
    88  	return &ColumnCoordinate{
    89  		Table: table,
    90  		Row:   row,
    91  		Column: Column{
    92  			Family: family,
    93  			Qual:   qual,
    94  		},
    95  	}
    96  }
    97  
    98  func (c *ColumnCoordinate) Write(w io.Writer) error {
    99  	err := iohelper.WriteVarBytes(w, c.Table)
   100  	if err != nil {
   101  		return errors.Trace(err)
   102  	}
   103  
   104  	err = iohelper.WriteVarBytes(w, c.Row)
   105  	if err != nil {
   106  		return errors.Trace(err)
   107  	}
   108  
   109  	err = c.Column.Write(w)
   110  	if err != nil {
   111  		return errors.Trace(err)
   112  	}
   113  
   114  	return nil
   115  }
   116  
   117  func (c *ColumnCoordinate) Equal(a *ColumnCoordinate) bool {
   118  	return bytes.Compare(c.Table, a.Table) == 0 &&
   119  		bytes.Compare(c.Row, a.Row) == 0 &&
   120  		bytes.Compare(c.Family, a.Family) == 0 &&
   121  		bytes.Compare(c.Qual, a.Qual) == 0
   122  }
   123  
   124  func (c *ColumnCoordinate) String() string {
   125  	b, err := encode(c.Table, c.Row, c.Family, c.Qual)
   126  	if err != nil {
   127  		return fmt.Sprintf("invalid column coordinate - %v", err)
   128  	}
   129  	return string(b)
   130  }
   131  
   132  func (c *ColumnCoordinate) ParseFromString(s string) error {
   133  	pairs, err := decode([]byte(s))
   134  	if err != nil {
   135  		return errors.Trace(err)
   136  	}
   137  
   138  	c.Table = pairs[0]
   139  	c.Row = pairs[1]
   140  	c.Family = pairs[2]
   141  	c.Qual = pairs[3]
   142  	return nil
   143  }
   144  
   145  func (c *ColumnCoordinate) ParseField(b iohelper.ByteMultiReader) error {
   146  	table, err := iohelper.ReadVarBytes(b)
   147  	if err != nil {
   148  		return errors.Trace(err)
   149  	}
   150  	c.Table = table
   151  
   152  	row, err := iohelper.ReadVarBytes(b)
   153  	if err != nil {
   154  		return errors.Trace(err)
   155  	}
   156  	c.Row = row
   157  
   158  	family, err := iohelper.ReadVarBytes(b)
   159  	if err != nil {
   160  		return errors.Trace(err)
   161  	}
   162  	c.Family = family
   163  
   164  	qual, err := iohelper.ReadVarBytes(b)
   165  	if err != nil {
   166  		return errors.Trace(err)
   167  	}
   168  	c.Qual = qual
   169  	return nil
   170  }
   171  
   172  func (c *ColumnCoordinate) GetColumn() *Column {
   173  	return &Column{
   174  		Family: c.Family,
   175  		Qual:   c.Qual,
   176  	}
   177  }