gohbase使用文档

目录

• 1. 建立连接
• 2. 创建表
• 3. 插入记录
• 4. 删除记录
• 5. 查询记录
  • 5.1 根据RowKey查询
  • 5.2 scan范围查询
  • 5.3 复杂查询(过滤器的使用)
    • 5.3.1 比较过滤器
    • 5.3.2 行过滤器
    • 5.3.3 列过滤器
    • 5.4.3 列族过滤器

1. 建立连接

import (
	"context"
	"github.com/tsuna/gohbase"
	"github.com/tsuna/gohbase/hrpc"
	"github.com/tsuna/gohbase/filter"
)
// 这里host指的是zk链接
client := gohbase.NewClient(host)
adminClient := gohbase.NewAdminClient(host)

2. 创建表

tableName := "test"  // 要创建的表名
families := map[string]map[string]string{
	"cf": {  // 列族名, 允许有多个列族, 以下参数全为非必填参数
		// 是否使用布隆过虑及使用何种方式
		// ROW: 对 ROW，行键的哈希在每次插入行时将被添加到布隆。
		// ROWCOL: 行键 + 列族 + 列族修饰的哈希将在每次插入行时添加到布隆
		// NONE:
		"BLOOMFILTER":         "ROW",
		// 数据保留的版本数, 如果不需要保留老版本数据, 可以调低此参数来节约磁盘空间
		"VERSIONS":            "3",
		// 是否常驻内存
		"IN_MEMORY":           "false",
		//
		"KEEP_DELETED_CELLS":  "false",
		//
		"DATA_BLOCK_ENCODING": "FAST_DIFF",
		// 默认是 2147483647 即:Integer.MAX_VALUE 值大概是68年
		// 这个参数是说明该列族数据的存活时间，单位是s
		// 这个参数可以根据具体的需求对数据设定存活时间，超过存过时间的数据将在表中不在显示，
		// 待下次major compact的时候再彻底删除数据.
		// 注意的是TTL设定之后 MIN_VERSIONS=>’0’ 这样设置之后，TTL时间戳过期后，
		// 将全部彻底删除该family下所有的数据，如果MIN_VERSIONS 不等于0那将保留
		// 最新的MIN_VERSIONS个版本的数据，其它的全部删除，比如MIN_VERSIONS=>’1’ 届时将保留一个最新版本的数据，
		// 其它版本的数据将不再保存。
		"TTL":                 "2147483647",
		// 指定列族是否采用压缩算法以及使用什么压缩算法NONE: 不使用压缩
		// SNAPPY/ZIPPY: 压缩比22.2%, 压缩172MB/s, 解压409MB/s
		// LZO: 压缩比20.5%, 压缩135MB/s, 解压410MB/s
		// GZIP: 压缩比13.4%, 压缩21MB/s, 解压118MB/s
		"COMPRESSION":         "NONE",
		// major compact的后保留的最少版本数
		"MIN_VERSIONS":        "0",
		//
		"BLOCKCACHE":          "true",
		//
		"BLOCKSIZE":           "65536",
		//
		"REPLICATION_SCOPE":   "0",
	}
}
ct := hrpc.NewCreateTable(context.Background(), []byte(tableName), families)
err := adminClient.CreateTable(ct)

3. 插入记录

rowKey := "18hd9j9aisdj9j9832dn9ooijd" // RowKey
value := map[string]map[string][]byte{
	"cf" { // 列族名, 与创建表时指定的名字保持一致
		"col1": []byte("val1"),  // 列与值, 列名可自由定义
		"col2": []byte("val2"),
		"col3": []byte("val3"),
	}
}
putRequest, err := hrpc.NewPutStr(context.Background(), tableName, rowKey, value)
res := client.Put(putRequest)

4. 删除记录

// 删除整条记录, value为空即可
req, err := hrpc.NewDelStr(context.Background(), tableName, rowKey, value)
res, err := client.Delete(req)

5. 查询记录

5.1 根据RowKey查询

getRequest, err = hrpc.NewGetStr(context.Background(), tableName, rowKey)
getRes, err = client.Get(getRequest)

5.2 scan范围查询

// 范围查询 [startRow, stopRow), 查询结果比较多时注意限制循环次数
getRequest, err := hrpc.NewScanRangeStr(context.Background(), tableName, startRow, stopRow)
scan := client.Scan(getRequest)
var res []*hrpc.Result
for {
	getRsp, err := scan.Next()
	if err == io.EOF || getRsp == nil {
		break
	}
	if err != nil {
		log.Print(err, "scan.Next")
	}
	res = append(res, getRsp)
}

5.3 复杂查询(过滤器的使用)

var hf []func(hrpc.Call) error
// 只查询固定的列{cf: [col1, col2]}
var Families map[string][]string
hf = append(hf, hrpc.Families(Families))
// f值的获取方式请继续往下阅读
hf = append(hf, hrpc.Filters(f))
getRequest, err = hrpc.NewGetStr(context.Background(), tableName, rowKey, hf...)
getRequest, err := hrpc.NewScanRangeStr(context.Background(), tableName, startRow, stopRow, hf...)

5.3.1 比较过滤器

比较过滤器不单独使用, 需配合其它过滤器使用

value := "aaaaa"
comparable := filter.NewByteArrayComparable([]byte(value))
var fc filter.Comparator
// 二进制比较器(精确匹配)
fc = filter.NewBinaryComparator(comparable)
// LongComparator
fc = filter.NewLongComparator(comparable)
// 前缀比较
fc = filter.NewBinaryPrefixComparator(comparable)
// BitComparator 字节比较
bitwiseOpInt := 1 // 1 AND, 2 OR, 3 XOR
bitwiseOp := filter.BitComparatorBitwiseOp(bitwiseOpInt)
fc = filter.NewBitComparator(bitwiseOp, comparable)
// NullComparator
fc = filter.NewNullComparator()
// 正则比较
/*
* 2: 忽略大小写, 4: 忽略空白和注释,
* 8: 多行匹配，默认情况下以行为单位匹配
* 32:使 . 能匹配所有符号
* 更多值参见JAVA正则flags值
*/
PatternFlags := 2
Charset := "utf-8"  // 字符集, 用于将行键转换为字符串以便与正则进行匹配
Engin := "JAVA"  // 正则引擎, JAVA, JONI
fc = filter.NewRegexStringComparator(value, PatternFlags, Charset, Engine)
// 子串比较
fc = filter.NewSubstringComparator(value)

/*
* 0: 小于, 1: 小于等于, 2: 等于, 3: 不等于,
* 4: 大于等于, 5: 大于, 6: 无操作
*/
CompareOp := 2
var f *filter.CompareFilter
f = filter.NewCompareFilter(filter.CompareType(CompareOp), fc)

5.3.2 行过滤器

var f filter.Filter
// 限制返回条数
f = filter.NewPageFilter(100)
// 前缀过滤
f = filter.NewPrefixFilter([]byte("prefix"))
// QualifierFilter
f = filter.NewQualifierFilter(f.(*filter.CompareFilter))
// 随机过滤
//设定一个概率值, 返回对应百分比的数据量(非严格执行)
//设为0则全部过滤, 设为1则全部包含
f = filter.NewRandomRowFilter(0.8)
// 使用比较过滤器过滤RowKey
f = filter.NewRowFilter(f.(*filter.CompareFilter))
// TimestampsFilter
f = filter.NewTimestampsFilter(r.Timestamps)
// 使用比较过滤器过滤value
f = filter.NewValueFilter(f.(*filter.CompareFilter))
// 范围过滤, 后两个参数分别表示返回结果是否包含startRow和stopRow
f = filter.NewRowRange([]byte(startRow), []byte(stopRow), true, false)
// 组合范围过滤器
var rowRangeList *filter.RowRange
f = filter.NewMultiRowRangeFilter(rowRangeList)
//scan操作时不包含截止行, 使用此过滤器可以将stopRow含在结果内
f = filter.NewInclusiveStopFilter([]byte(stopRow))
// FuzzyRowFilter
var bbp []*filter.BytesBytesPair
bbp = append(bbp, filter.NewBytesBytesPair([]byte, []byte))
f = filter.NewFuzzyRowFilter(bbp)

5.3.3 列过滤器

// 限制返回的列的数量
f = filter.NewColumnCountGetFilter(10)
// 列分页
f = filter.NewColumnPaginationFilter(limit, offset, []byte(columnOffset))
// 通过前缀过滤列
f = filter.NewColumnPrefixFilter([]byte(prefix))
// 列范围匹配过滤器
// 后两个参数控制是否包含边界
f = filter.NewColumnRangeFilter([]byte(minColumn), []byte(maxColumn), true, false)
// DependentColumnFilter
f = filter.NewDependentColumnFilter(f.(*filter.CompareFilter), []byte(c.ColumnFamily), []byte(c.ColumnQualifier), true)
//多列前缀匹配
f = filter.NewMultipleColumnPrefixFilter(sortedPrefix)
// SingleColumnValueFilter
f = filter.NewSingleColumnValueFilter([]byte(ColumnFamily),
	[]byte(ColumnQualifier), compareOP, fc,
	FilterIfMissing, LatestVersionOnly)
// SingleColumnValueExcludeFilter
f = filter.NewSingleColumnValueExcludeFilter(f.(*filter.SingleColumnValueFilter))
//返回的数据不包括实际的单元值，只包含行键与列
f = filter.NewKeyOnlyFilter(true)
//只返回每一行的第一列
f = filter.NewFirstKeyOnlyFilter()
//通过设置一组需要匹配的列，只要匹配到任意一个列就会停止这一行的扫描操作进行下一行的扫描
f = filter.NewFirstKeyValueMatchingQualifiersFilter([][]byte)

5.4.3 列族过滤器

f = filter.NewFamilyFilter(f.(*filter.CompareFilter))