854 lines
23 KiB
Go
854 lines
23 KiB
Go
// Copyright (C) 2015 The GoHBase Authors. All rights reserved.
|
|
// This file is part of GoHBase.
|
|
// Use of this source code is governed by the Apache License 2.0
|
|
// that can be found in the COPYING file.
|
|
|
|
package filter
|
|
|
|
import (
|
|
"errors"
|
|
|
|
"github.com/golang/protobuf/proto"
|
|
"github.com/tsuna/gohbase/pb"
|
|
)
|
|
|
|
const filterPath = "org.apache.hadoop.hbase.filter."
|
|
|
|
// ListOperator is TODO
|
|
type ListOperator int32
|
|
|
|
func (o ListOperator) isValid() bool {
|
|
return o >= 1 && o <= 2
|
|
}
|
|
|
|
func (o ListOperator) toPB() *pb.FilterList_Operator {
|
|
op := pb.FilterList_Operator(o)
|
|
return &op
|
|
}
|
|
|
|
// Constants is TODO
|
|
const (
|
|
MustPassAll ListOperator = 1
|
|
MustPassOne ListOperator = 2
|
|
)
|
|
|
|
// CompareType is TODO
|
|
type CompareType int32
|
|
|
|
func (c CompareType) isValid() bool {
|
|
return c >= 0 && c <= 6
|
|
}
|
|
|
|
// Constants is TODO
|
|
const (
|
|
Less CompareType = 0
|
|
LessOrEqual CompareType = 1
|
|
Equal CompareType = 2
|
|
NotEqual CompareType = 3
|
|
GreaterOrEqual CompareType = 4
|
|
Greater CompareType = 5
|
|
NoOp CompareType = 6
|
|
)
|
|
|
|
// Ensure our types implement Filter correctly.
|
|
var _ Filter = (*List)(nil)
|
|
var _ Filter = (*ColumnCountGetFilter)(nil)
|
|
var _ Filter = (*ColumnPaginationFilter)(nil)
|
|
var _ Filter = (*ColumnPrefixFilter)(nil)
|
|
var _ Filter = (*ColumnRangeFilter)(nil)
|
|
var _ Filter = (*CompareFilter)(nil)
|
|
var _ Filter = (*DependentColumnFilter)(nil)
|
|
var _ Filter = (*FamilyFilter)(nil)
|
|
var _ Filter = (*Wrapper)(nil)
|
|
var _ Filter = (*FirstKeyOnlyFilter)(nil)
|
|
var _ Filter = (*FirstKeyValueMatchingQualifiersFilter)(nil)
|
|
var _ Filter = (*FuzzyRowFilter)(nil)
|
|
var _ Filter = (*InclusiveStopFilter)(nil)
|
|
var _ Filter = (*KeyOnlyFilter)(nil)
|
|
var _ Filter = (*MultipleColumnPrefixFilter)(nil)
|
|
var _ Filter = (*PageFilter)(nil)
|
|
var _ Filter = (*PrefixFilter)(nil)
|
|
var _ Filter = (*QualifierFilter)(nil)
|
|
var _ Filter = (*RandomRowFilter)(nil)
|
|
var _ Filter = (*RowFilter)(nil)
|
|
var _ Filter = (*SingleColumnValueFilter)(nil)
|
|
var _ Filter = (*SingleColumnValueExcludeFilter)(nil)
|
|
var _ Filter = (*SkipFilter)(nil)
|
|
var _ Filter = (*TimestampsFilter)(nil)
|
|
var _ Filter = (*ValueFilter)(nil)
|
|
var _ Filter = (*WhileMatchFilter)(nil)
|
|
var _ Filter = (*AllFilter)(nil)
|
|
var _ Filter = (*RowRange)(nil)
|
|
var _ Filter = (*MultiRowRangeFilter)(nil)
|
|
|
|
// Filter is TODO
|
|
type Filter interface {
|
|
// ConstructPBFilter creates and returns the filter encoded in a pb.Filter type
|
|
// - For most filters this just involves creating the special filter object,
|
|
// serializing it, and then creating a standard Filter object with the name and
|
|
// serialization inside.
|
|
// - For FilterLists this requires creating the protobuf FilterList which contains
|
|
// an array []*pb.Filter (meaning we have to create, serialize, create all objects
|
|
// in that array), serialize the newly created pb.FilterList and then create a
|
|
// pb.Filter object containing that new serialization.
|
|
ConstructPBFilter() (*pb.Filter, error)
|
|
}
|
|
|
|
// BytesBytesPair is a type used in FuzzyRowFilter. Want to avoid users having
|
|
// to interact directly with the protobuf generated file so exposing here.
|
|
type BytesBytesPair pb.BytesBytesPair
|
|
|
|
// NewBytesBytesPair is TODO
|
|
func NewBytesBytesPair(first []byte, second []byte) *BytesBytesPair {
|
|
return &BytesBytesPair{
|
|
First: first,
|
|
Second: second,
|
|
}
|
|
}
|
|
|
|
/*
|
|
Each filter below has three primary methods/declarations, each of which can be summarized
|
|
as follows -
|
|
|
|
1. Type declaration. Create a new type for each filter. A 'Name' field is required but
|
|
you can create as many other fields as you like. These are purely local and will be
|
|
transcribed into a pb.Filter type by ConstructPBFilter()
|
|
2. Constructor. Given a few parameters create the above type and return it to the callee.
|
|
3. ConstructPBFilter. Take our local representation of a filter object and create the
|
|
appropriate pb.Filter object. Return the pb.Filter object.
|
|
|
|
You may define any additional methods you like (see FilterList) but be aware that as soon
|
|
as the returned object is type casted to a Filter (e.g. appending it to an array of Filters)
|
|
it loses the ability to call those additional functions.
|
|
*/
|
|
|
|
// List is TODO
|
|
type List pb.FilterList
|
|
|
|
// NewList is TODO
|
|
func NewList(operator ListOperator, filters ...Filter) *List {
|
|
f := &List{
|
|
Operator: operator.toPB(),
|
|
}
|
|
f.AddFilters(filters...)
|
|
return f
|
|
}
|
|
|
|
// AddFilters is TODO
|
|
func (f *List) AddFilters(filters ...Filter) {
|
|
for _, filter := range filters {
|
|
fpb, err := filter.ConstructPBFilter()
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
f.Filters = append(f.Filters, fpb)
|
|
}
|
|
}
|
|
|
|
// ConstructPBFilter is TODO
|
|
func (f *List) ConstructPBFilter() (*pb.Filter, error) {
|
|
if !ListOperator(*f.Operator).isValid() {
|
|
return nil, errors.New("invalid operator specified")
|
|
}
|
|
|
|
serializedFilter, err := proto.Marshal((*pb.FilterList)(f))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
filter := &pb.Filter{
|
|
Name: proto.String(filterPath + "FilterList"),
|
|
SerializedFilter: serializedFilter,
|
|
}
|
|
return filter, nil
|
|
}
|
|
|
|
// ColumnCountGetFilter is TODO
|
|
type ColumnCountGetFilter pb.ColumnCountGetFilter
|
|
|
|
// NewColumnCountGetFilter is TODO
|
|
func NewColumnCountGetFilter(limit int32) *ColumnCountGetFilter {
|
|
return &ColumnCountGetFilter{
|
|
Limit: proto.Int32(limit),
|
|
}
|
|
}
|
|
|
|
// ConstructPBFilter is TODO
|
|
func (f *ColumnCountGetFilter) ConstructPBFilter() (*pb.Filter, error) {
|
|
serializedFilter, err := proto.Marshal((*pb.ColumnCountGetFilter)(f))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
filter := &pb.Filter{
|
|
Name: proto.String(filterPath + "ColumnCountGetFilter"),
|
|
SerializedFilter: serializedFilter,
|
|
}
|
|
return filter, nil
|
|
}
|
|
|
|
// ColumnPaginationFilter is TODO
|
|
type ColumnPaginationFilter pb.ColumnPaginationFilter
|
|
|
|
// NewColumnPaginationFilter is TODO
|
|
func NewColumnPaginationFilter(limit, offset int32, columnOffset []byte) *ColumnPaginationFilter {
|
|
return &ColumnPaginationFilter{
|
|
Limit: proto.Int32(limit),
|
|
Offset: proto.Int32(offset),
|
|
ColumnOffset: columnOffset,
|
|
}
|
|
}
|
|
|
|
// ConstructPBFilter is TODO
|
|
func (f *ColumnPaginationFilter) ConstructPBFilter() (*pb.Filter, error) {
|
|
serializedFilter, err := proto.Marshal((*pb.ColumnPaginationFilter)(f))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
filter := &pb.Filter{
|
|
Name: proto.String(filterPath + "ColumnPaginationFilter"),
|
|
SerializedFilter: serializedFilter,
|
|
}
|
|
return filter, nil
|
|
}
|
|
|
|
// ColumnPrefixFilter is TODO
|
|
type ColumnPrefixFilter pb.ColumnPrefixFilter
|
|
|
|
// NewColumnPrefixFilter is TODO
|
|
func NewColumnPrefixFilter(prefix []byte) *ColumnPrefixFilter {
|
|
return &ColumnPrefixFilter{
|
|
Prefix: prefix,
|
|
}
|
|
}
|
|
|
|
// ConstructPBFilter is TODO
|
|
func (f *ColumnPrefixFilter) ConstructPBFilter() (*pb.Filter, error) {
|
|
serializedFilter, err := proto.Marshal((*pb.ColumnPrefixFilter)(f))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
filter := &pb.Filter{
|
|
Name: proto.String(filterPath + "ColumnPrefixFilter"),
|
|
SerializedFilter: serializedFilter,
|
|
}
|
|
return filter, nil
|
|
}
|
|
|
|
// ColumnRangeFilter is TODO
|
|
type ColumnRangeFilter pb.ColumnRangeFilter
|
|
|
|
// NewColumnRangeFilter is TODO
|
|
func NewColumnRangeFilter(minColumn, maxColumn []byte,
|
|
minColumnInclusive, maxColumnInclusive bool) *ColumnRangeFilter {
|
|
return &ColumnRangeFilter{
|
|
MinColumn: minColumn,
|
|
MaxColumn: maxColumn,
|
|
MinColumnInclusive: proto.Bool(minColumnInclusive),
|
|
MaxColumnInclusive: proto.Bool(maxColumnInclusive),
|
|
}
|
|
}
|
|
|
|
// ConstructPBFilter is TODO
|
|
func (f *ColumnRangeFilter) ConstructPBFilter() (*pb.Filter, error) {
|
|
serializedFilter, err := proto.Marshal((*pb.ColumnRangeFilter)(f))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
filter := &pb.Filter{
|
|
Name: proto.String(filterPath + "ColumnRangeFilter"),
|
|
SerializedFilter: serializedFilter,
|
|
}
|
|
return filter, nil
|
|
}
|
|
|
|
// CompareFilter is TODO
|
|
type CompareFilter pb.CompareFilter
|
|
|
|
// NewCompareFilter is TODO
|
|
func NewCompareFilter(compareOp CompareType, comparatorObj Comparator) *CompareFilter {
|
|
op := pb.CompareType(compareOp)
|
|
obj, err := comparatorObj.ConstructPBComparator()
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
return &CompareFilter{
|
|
CompareOp: &op,
|
|
Comparator: obj,
|
|
}
|
|
}
|
|
|
|
// ConstructPBFilter is TODO
|
|
func (f *CompareFilter) ConstructPBFilter() (*pb.Filter, error) {
|
|
serializedFilter, err := proto.Marshal((*pb.CompareFilter)(f))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
filter := &pb.Filter{
|
|
Name: proto.String(filterPath + "CompareFilter"),
|
|
SerializedFilter: serializedFilter,
|
|
}
|
|
return filter, nil
|
|
}
|
|
|
|
// DependentColumnFilter is TODO
|
|
type DependentColumnFilter pb.DependentColumnFilter
|
|
|
|
// NewDependentColumnFilter is TODO
|
|
func NewDependentColumnFilter(compareFilter *CompareFilter, columnFamily, columnQualifier []byte,
|
|
dropDependentColumn bool) *DependentColumnFilter {
|
|
return &DependentColumnFilter{
|
|
CompareFilter: (*pb.CompareFilter)(compareFilter),
|
|
ColumnFamily: columnFamily,
|
|
ColumnQualifier: columnQualifier,
|
|
DropDependentColumn: proto.Bool(dropDependentColumn),
|
|
}
|
|
}
|
|
|
|
// ConstructPBFilter is TODO
|
|
func (f *DependentColumnFilter) ConstructPBFilter() (*pb.Filter, error) {
|
|
serializedFilter, err := proto.Marshal((*pb.DependentColumnFilter)(f))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
filter := &pb.Filter{
|
|
Name: proto.String(filterPath + "DependentColumnFilter"),
|
|
SerializedFilter: serializedFilter,
|
|
}
|
|
return filter, nil
|
|
}
|
|
|
|
// FamilyFilter is TODO
|
|
type FamilyFilter pb.FamilyFilter
|
|
|
|
// NewFamilyFilter is TODO
|
|
func NewFamilyFilter(compareFilter *CompareFilter) *FamilyFilter {
|
|
return &FamilyFilter{
|
|
CompareFilter: (*pb.CompareFilter)(compareFilter),
|
|
}
|
|
}
|
|
|
|
// ConstructPBFilter is TODO
|
|
func (f *FamilyFilter) ConstructPBFilter() (*pb.Filter, error) {
|
|
serializedFilter, err := proto.Marshal((*pb.FamilyFilter)(f))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
filter := &pb.Filter{
|
|
Name: proto.String(filterPath + "FamilyFilter"),
|
|
SerializedFilter: serializedFilter,
|
|
}
|
|
return filter, nil
|
|
}
|
|
|
|
// Wrapper is TODO
|
|
type Wrapper pb.FilterWrapper
|
|
|
|
// NewWrapper is TODO
|
|
func NewWrapper(wrappedFilter Filter) *Wrapper {
|
|
f, err := wrappedFilter.ConstructPBFilter()
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
return &Wrapper{
|
|
Filter: f,
|
|
}
|
|
}
|
|
|
|
// ConstructPBFilter is TODO
|
|
func (f *Wrapper) ConstructPBFilter() (*pb.Filter, error) {
|
|
serializedFilter, err := proto.Marshal((*pb.FilterWrapper)(f))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
filter := &pb.Filter{
|
|
Name: proto.String(filterPath + "FilterWrapper"),
|
|
SerializedFilter: serializedFilter,
|
|
}
|
|
return filter, nil
|
|
}
|
|
|
|
// FirstKeyOnlyFilter is TODO
|
|
type FirstKeyOnlyFilter struct{}
|
|
|
|
// NewFirstKeyOnlyFilter is TODO
|
|
func NewFirstKeyOnlyFilter() FirstKeyOnlyFilter {
|
|
return FirstKeyOnlyFilter{}
|
|
}
|
|
|
|
// ConstructPBFilter is TODO
|
|
func (f FirstKeyOnlyFilter) ConstructPBFilter() (*pb.Filter, error) {
|
|
return &pb.Filter{
|
|
Name: proto.String(filterPath + "FirstKeyOnlyFilter"),
|
|
SerializedFilter: pb.MustMarshal(&pb.FirstKeyOnlyFilter{}),
|
|
}, nil
|
|
}
|
|
|
|
// FirstKeyValueMatchingQualifiersFilter is TODO
|
|
type FirstKeyValueMatchingQualifiersFilter pb.FirstKeyValueMatchingQualifiersFilter
|
|
|
|
// NewFirstKeyValueMatchingQualifiersFilter is TODO
|
|
func NewFirstKeyValueMatchingQualifiersFilter(
|
|
qualifiers [][]byte) *FirstKeyValueMatchingQualifiersFilter {
|
|
return &FirstKeyValueMatchingQualifiersFilter{
|
|
Qualifiers: qualifiers,
|
|
}
|
|
}
|
|
|
|
// ConstructPBFilter is TODO
|
|
func (f *FirstKeyValueMatchingQualifiersFilter) ConstructPBFilter() (*pb.Filter, error) {
|
|
serializedFilter, err := proto.Marshal((*pb.FirstKeyValueMatchingQualifiersFilter)(f))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
filter := &pb.Filter{
|
|
Name: proto.String(filterPath + "FirstKeyValueMatchingQualifiersFilter"),
|
|
SerializedFilter: serializedFilter,
|
|
}
|
|
return filter, nil
|
|
}
|
|
|
|
// FuzzyRowFilter is TODO
|
|
type FuzzyRowFilter pb.FuzzyRowFilter
|
|
|
|
// NewFuzzyRowFilter is TODO
|
|
func NewFuzzyRowFilter(pairs []*BytesBytesPair) *FuzzyRowFilter {
|
|
p := make([]*pb.BytesBytesPair, len(pairs))
|
|
for i, pair := range pairs {
|
|
p[i] = (*pb.BytesBytesPair)(pair)
|
|
}
|
|
return &FuzzyRowFilter{
|
|
FuzzyKeysData: p,
|
|
}
|
|
}
|
|
|
|
// ConstructPBFilter is TODO
|
|
func (f *FuzzyRowFilter) ConstructPBFilter() (*pb.Filter, error) {
|
|
serializedFilter, err := proto.Marshal((*pb.FuzzyRowFilter)(f))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
filter := &pb.Filter{
|
|
Name: proto.String(filterPath + "FuzzyRowFilter"),
|
|
SerializedFilter: serializedFilter,
|
|
}
|
|
return filter, nil
|
|
}
|
|
|
|
// InclusiveStopFilter is TODO
|
|
type InclusiveStopFilter pb.InclusiveStopFilter
|
|
|
|
// NewInclusiveStopFilter is TODO
|
|
func NewInclusiveStopFilter(stopRowKey []byte) *InclusiveStopFilter {
|
|
return &InclusiveStopFilter{
|
|
StopRowKey: stopRowKey,
|
|
}
|
|
}
|
|
|
|
// ConstructPBFilter is TODO
|
|
func (f *InclusiveStopFilter) ConstructPBFilter() (*pb.Filter, error) {
|
|
serializedFilter, err := proto.Marshal((*pb.InclusiveStopFilter)(f))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
filter := &pb.Filter{
|
|
Name: proto.String(filterPath + "InclusiveStopFilter"),
|
|
SerializedFilter: serializedFilter,
|
|
}
|
|
return filter, nil
|
|
}
|
|
|
|
// KeyOnlyFilter is TODO
|
|
type KeyOnlyFilter pb.KeyOnlyFilter
|
|
|
|
// NewKeyOnlyFilter is TODO
|
|
func NewKeyOnlyFilter(lenAsVal bool) *KeyOnlyFilter {
|
|
return &KeyOnlyFilter{
|
|
LenAsVal: proto.Bool(lenAsVal),
|
|
}
|
|
}
|
|
|
|
// ConstructPBFilter is TODO
|
|
func (f *KeyOnlyFilter) ConstructPBFilter() (*pb.Filter, error) {
|
|
serializedFilter, err := proto.Marshal((*pb.KeyOnlyFilter)(f))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
filter := &pb.Filter{
|
|
Name: proto.String(filterPath + "KeyOnlyFilter"),
|
|
SerializedFilter: serializedFilter,
|
|
}
|
|
return filter, nil
|
|
}
|
|
|
|
// MultipleColumnPrefixFilter is TODO
|
|
type MultipleColumnPrefixFilter pb.MultipleColumnPrefixFilter
|
|
|
|
// NewMultipleColumnPrefixFilter is TODO
|
|
func NewMultipleColumnPrefixFilter(sortedPrefixes [][]byte) *MultipleColumnPrefixFilter {
|
|
return &MultipleColumnPrefixFilter{
|
|
SortedPrefixes: sortedPrefixes,
|
|
}
|
|
}
|
|
|
|
// ConstructPBFilter is TODO
|
|
func (f *MultipleColumnPrefixFilter) ConstructPBFilter() (*pb.Filter, error) {
|
|
serializedFilter, err := proto.Marshal((*pb.MultipleColumnPrefixFilter)(f))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
filter := &pb.Filter{
|
|
Name: proto.String(filterPath + "MultipleColumnPrefixFilter"),
|
|
SerializedFilter: serializedFilter,
|
|
}
|
|
return filter, nil
|
|
}
|
|
|
|
// PageFilter is TODO
|
|
type PageFilter pb.PageFilter
|
|
|
|
// NewPageFilter is TODO
|
|
func NewPageFilter(pageSize int64) *PageFilter {
|
|
return &PageFilter{
|
|
PageSize: proto.Int64(pageSize),
|
|
}
|
|
}
|
|
|
|
// ConstructPBFilter is TODO
|
|
func (f *PageFilter) ConstructPBFilter() (*pb.Filter, error) {
|
|
serializedFilter, err := proto.Marshal((*pb.PageFilter)(f))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
filter := &pb.Filter{
|
|
Name: proto.String(filterPath + "PageFilter"),
|
|
SerializedFilter: serializedFilter,
|
|
}
|
|
return filter, nil
|
|
}
|
|
|
|
// PrefixFilter is TODO
|
|
type PrefixFilter pb.PrefixFilter
|
|
|
|
// NewPrefixFilter is TODO
|
|
func NewPrefixFilter(prefix []byte) *PrefixFilter {
|
|
return &PrefixFilter{
|
|
Prefix: prefix,
|
|
}
|
|
}
|
|
|
|
// ConstructPBFilter is TODO
|
|
func (f *PrefixFilter) ConstructPBFilter() (*pb.Filter, error) {
|
|
serializedFilter, err := proto.Marshal((*pb.PrefixFilter)(f))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
filter := &pb.Filter{
|
|
Name: proto.String(filterPath + "PrefixFilter"),
|
|
SerializedFilter: serializedFilter,
|
|
}
|
|
return filter, nil
|
|
}
|
|
|
|
// QualifierFilter is TODO
|
|
type QualifierFilter pb.QualifierFilter
|
|
|
|
// NewQualifierFilter is TODO
|
|
func NewQualifierFilter(compareFilter *CompareFilter) *QualifierFilter {
|
|
return &QualifierFilter{
|
|
CompareFilter: (*pb.CompareFilter)(compareFilter),
|
|
}
|
|
}
|
|
|
|
// ConstructPBFilter is TODO
|
|
func (f *QualifierFilter) ConstructPBFilter() (*pb.Filter, error) {
|
|
serializedFilter, err := proto.Marshal((*pb.QualifierFilter)(f))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
filter := &pb.Filter{
|
|
Name: proto.String(filterPath + "QualifierFilter"),
|
|
SerializedFilter: serializedFilter,
|
|
}
|
|
return filter, nil
|
|
}
|
|
|
|
// RandomRowFilter is TODO
|
|
type RandomRowFilter pb.RandomRowFilter
|
|
|
|
// NewRandomRowFilter is TODO
|
|
func NewRandomRowFilter(chance float32) *RandomRowFilter {
|
|
return &RandomRowFilter{
|
|
Chance: proto.Float32(chance),
|
|
}
|
|
}
|
|
|
|
// ConstructPBFilter is TODO
|
|
func (f *RandomRowFilter) ConstructPBFilter() (*pb.Filter, error) {
|
|
serializedFilter, err := proto.Marshal((*pb.RandomRowFilter)(f))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
filter := &pb.Filter{
|
|
Name: proto.String(filterPath + "RandomRowFilter"),
|
|
SerializedFilter: serializedFilter,
|
|
}
|
|
return filter, nil
|
|
}
|
|
|
|
// RowFilter is TODO
|
|
type RowFilter pb.RowFilter
|
|
|
|
// NewRowFilter is TODO
|
|
func NewRowFilter(compareFilter *CompareFilter) *RowFilter {
|
|
return &RowFilter{
|
|
CompareFilter: (*pb.CompareFilter)(compareFilter),
|
|
}
|
|
}
|
|
|
|
// ConstructPBFilter is TODO
|
|
func (f *RowFilter) ConstructPBFilter() (*pb.Filter, error) {
|
|
serializedFilter, err := proto.Marshal((*pb.RowFilter)(f))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
filter := &pb.Filter{
|
|
Name: proto.String(filterPath + "RowFilter"),
|
|
SerializedFilter: serializedFilter,
|
|
}
|
|
return filter, nil
|
|
}
|
|
|
|
// SingleColumnValueFilter is TODO
|
|
type SingleColumnValueFilter pb.SingleColumnValueFilter
|
|
|
|
// NewSingleColumnValueFilter is TODO
|
|
func NewSingleColumnValueFilter(columnFamily, columnQualifier []byte, compareOp CompareType,
|
|
comparatorObj Comparator, filterIfMissing, latestVersionOnly bool) *SingleColumnValueFilter {
|
|
obj, err := comparatorObj.ConstructPBComparator()
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
return &SingleColumnValueFilter{
|
|
ColumnFamily: columnFamily,
|
|
ColumnQualifier: columnQualifier,
|
|
CompareOp: (*pb.CompareType)(&compareOp),
|
|
Comparator: obj,
|
|
FilterIfMissing: proto.Bool(filterIfMissing),
|
|
LatestVersionOnly: proto.Bool(latestVersionOnly),
|
|
}
|
|
}
|
|
|
|
// ConstructPB is TODO
|
|
func (f *SingleColumnValueFilter) ConstructPB() (*pb.SingleColumnValueFilter, error) {
|
|
if !CompareType(*f.CompareOp).isValid() {
|
|
return nil, errors.New("invalid compare operation specified")
|
|
}
|
|
|
|
return (*pb.SingleColumnValueFilter)(f), nil
|
|
}
|
|
|
|
// ConstructPBFilter is TODO
|
|
func (f *SingleColumnValueFilter) ConstructPBFilter() (*pb.Filter, error) {
|
|
serializedFilter, err := proto.Marshal((*pb.SingleColumnValueFilter)(f))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
filter := &pb.Filter{
|
|
Name: proto.String(filterPath + "SingleColumnValueFilter"),
|
|
SerializedFilter: serializedFilter,
|
|
}
|
|
return filter, nil
|
|
}
|
|
|
|
// SingleColumnValueExcludeFilter is TODO
|
|
type SingleColumnValueExcludeFilter pb.SingleColumnValueExcludeFilter
|
|
|
|
// NewSingleColumnValueExcludeFilter is TODO
|
|
func NewSingleColumnValueExcludeFilter(
|
|
filter *SingleColumnValueFilter) *SingleColumnValueExcludeFilter {
|
|
return &SingleColumnValueExcludeFilter{
|
|
SingleColumnValueFilter: (*pb.SingleColumnValueFilter)(filter),
|
|
}
|
|
}
|
|
|
|
// ConstructPBFilter is TODO
|
|
func (f *SingleColumnValueExcludeFilter) ConstructPBFilter() (*pb.Filter, error) {
|
|
serializedFilter, err := proto.Marshal((*pb.SingleColumnValueExcludeFilter)(f))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
filter := &pb.Filter{
|
|
Name: proto.String(filterPath + "SingleColumnValueExcludeFilter"),
|
|
SerializedFilter: serializedFilter,
|
|
}
|
|
return filter, nil
|
|
}
|
|
|
|
// SkipFilter is TODO
|
|
type SkipFilter pb.SkipFilter
|
|
|
|
// NewSkipFilter is TODO
|
|
func NewSkipFilter(skippingFilter Filter) *SkipFilter {
|
|
f, err := skippingFilter.ConstructPBFilter()
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
return &SkipFilter{
|
|
Filter: f,
|
|
}
|
|
}
|
|
|
|
// ConstructPBFilter is TODO
|
|
func (f *SkipFilter) ConstructPBFilter() (*pb.Filter, error) {
|
|
serializedFilter, err := proto.Marshal((*pb.SkipFilter)(f))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
filter := &pb.Filter{
|
|
Name: proto.String(filterPath + "SkipFilter"),
|
|
SerializedFilter: serializedFilter,
|
|
}
|
|
return filter, nil
|
|
}
|
|
|
|
// TimestampsFilter is TODO
|
|
type TimestampsFilter pb.TimestampsFilter
|
|
|
|
// NewTimestampsFilter is TODO
|
|
func NewTimestampsFilter(timestamps []int64) *TimestampsFilter {
|
|
return &TimestampsFilter{
|
|
Timestamps: timestamps,
|
|
}
|
|
}
|
|
|
|
// ConstructPBFilter is TODO
|
|
func (f *TimestampsFilter) ConstructPBFilter() (*pb.Filter, error) {
|
|
serializedFilter, err := proto.Marshal((*pb.TimestampsFilter)(f))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
filter := &pb.Filter{
|
|
Name: proto.String(filterPath + "TimestampsFilter"),
|
|
SerializedFilter: serializedFilter,
|
|
}
|
|
return filter, nil
|
|
}
|
|
|
|
// ValueFilter is TODO
|
|
type ValueFilter pb.ValueFilter
|
|
|
|
// NewValueFilter is TODO
|
|
func NewValueFilter(compareFilter *CompareFilter) *ValueFilter {
|
|
return &ValueFilter{
|
|
CompareFilter: (*pb.CompareFilter)(compareFilter),
|
|
}
|
|
}
|
|
|
|
// ConstructPBFilter is TODO
|
|
func (f *ValueFilter) ConstructPBFilter() (*pb.Filter, error) {
|
|
serializedFilter, err := proto.Marshal((*pb.ValueFilter)(f))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
filter := &pb.Filter{
|
|
Name: proto.String(filterPath + "ValueFilter"),
|
|
SerializedFilter: serializedFilter,
|
|
}
|
|
return filter, nil
|
|
}
|
|
|
|
// WhileMatchFilter is TODO
|
|
type WhileMatchFilter pb.WhileMatchFilter
|
|
|
|
// NewWhileMatchFilter is TODO
|
|
func NewWhileMatchFilter(matchingFilter Filter) *WhileMatchFilter {
|
|
f, err := matchingFilter.ConstructPBFilter()
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
return &WhileMatchFilter{
|
|
Filter: f,
|
|
}
|
|
}
|
|
|
|
// ConstructPBFilter is TODO
|
|
func (f *WhileMatchFilter) ConstructPBFilter() (*pb.Filter, error) {
|
|
serializedFilter, err := proto.Marshal((*pb.WhileMatchFilter)(f))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
filter := &pb.Filter{
|
|
Name: proto.String(filterPath + "WhileMatchFilter"),
|
|
SerializedFilter: serializedFilter,
|
|
}
|
|
return filter, nil
|
|
}
|
|
|
|
// AllFilter is TODO
|
|
type AllFilter struct{}
|
|
|
|
// NewAllFilter is TODO
|
|
func NewAllFilter() AllFilter {
|
|
return AllFilter{}
|
|
}
|
|
|
|
// ConstructPBFilter is TODO
|
|
func (f *AllFilter) ConstructPBFilter() (*pb.Filter, error) {
|
|
return &pb.Filter{
|
|
Name: proto.String(filterPath + "FilterAllFilter"),
|
|
SerializedFilter: pb.MustMarshal(&pb.FilterAllFilter{}),
|
|
}, nil
|
|
}
|
|
|
|
// RowRange is TODO
|
|
type RowRange pb.RowRange
|
|
|
|
// NewRowRange is TODO
|
|
func NewRowRange(startRow, stopRow []byte, startRowInclusive, stopRowInclusive bool) *RowRange {
|
|
return &RowRange{
|
|
StartRow: startRow,
|
|
StartRowInclusive: proto.Bool(startRowInclusive),
|
|
StopRow: stopRow,
|
|
StopRowInclusive: proto.Bool(stopRowInclusive),
|
|
}
|
|
}
|
|
|
|
// ConstructPBFilter is TODO
|
|
func (f *RowRange) ConstructPBFilter() (*pb.Filter, error) {
|
|
serializedFilter, err := proto.Marshal((*pb.RowRange)(f))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
filter := &pb.Filter{
|
|
Name: proto.String(filterPath + "RowRange"),
|
|
SerializedFilter: serializedFilter,
|
|
}
|
|
return filter, nil
|
|
}
|
|
|
|
// MultiRowRangeFilter is TODO
|
|
type MultiRowRangeFilter pb.MultiRowRangeFilter
|
|
|
|
// NewMultiRowRangeFilter is TODO
|
|
func NewMultiRowRangeFilter(rowRangeList []*RowRange) *MultiRowRangeFilter {
|
|
rangeList := make([]*pb.RowRange, len(rowRangeList))
|
|
for i, rr := range rowRangeList {
|
|
rangeList[i] = (*pb.RowRange)(rr)
|
|
}
|
|
return &MultiRowRangeFilter{
|
|
RowRangeList: rangeList,
|
|
}
|
|
}
|
|
|
|
// ConstructPBFilter is TODO
|
|
func (f *MultiRowRangeFilter) ConstructPBFilter() (*pb.Filter, error) {
|
|
serializedFilter, err := proto.Marshal((*pb.MultiRowRangeFilter)(f))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
filter := &pb.Filter{
|
|
Name: proto.String(filterPath + "MultiRowRangeFilter"),
|
|
SerializedFilter: serializedFilter,
|
|
}
|
|
return filter, nil
|
|
}
|