featurebase/proto/pilosa.pb.go

// Code generated by protoc-gen-go. DO NOT EDIT.
// source: pilosa.proto

package pilosa

import (
	context "context"
	fmt "fmt"
	proto "github.com/golang/protobuf/proto"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
	math "math"
)

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf

// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package

type QueryPQLRequest struct {
	Index                string   `protobuf:"bytes,1,opt,name=index,proto3" json:"index,omitempty"`
	Pql                  string   `protobuf:"bytes,2,opt,name=pql,proto3" json:"pql,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *QueryPQLRequest) Reset()         { *m = QueryPQLRequest{} }
func (m *QueryPQLRequest) String() string { return proto.CompactTextString(m) }
func (*QueryPQLRequest) ProtoMessage()    {}
func (*QueryPQLRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_ef0691a44d1e275c, []int{0}
}

func (m *QueryPQLRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_QueryPQLRequest.Unmarshal(m, b)
}
func (m *QueryPQLRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_QueryPQLRequest.Marshal(b, m, deterministic)
}
func (m *QueryPQLRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_QueryPQLRequest.Merge(m, src)
}
func (m *QueryPQLRequest) XXX_Size() int {
	return xxx_messageInfo_QueryPQLRequest.Size(m)
}
func (m *QueryPQLRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_QueryPQLRequest.DiscardUnknown(m)
}

var xxx_messageInfo_QueryPQLRequest proto.InternalMessageInfo

func (m *QueryPQLRequest) GetIndex() string {
	if m != nil {
		return m.Index
	}
	return ""
}

func (m *QueryPQLRequest) GetPql() string {
	if m != nil {
		return m.Pql
	}
	return ""
}

type RowResponse struct {
	Headers              []*ColumnInfo     `protobuf:"bytes,1,rep,name=headers,proto3" json:"headers,omitempty"`
	Columns              []*ColumnResponse `protobuf:"bytes,2,rep,name=columns,proto3" json:"columns,omitempty"`
	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
	XXX_unrecognized     []byte            `json:"-"`
	XXX_sizecache        int32             `json:"-"`
}

func (m *RowResponse) Reset()         { *m = RowResponse{} }
func (m *RowResponse) String() string { return proto.CompactTextString(m) }
func (*RowResponse) ProtoMessage()    {}
func (*RowResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_ef0691a44d1e275c, []int{1}
}

func (m *RowResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_RowResponse.Unmarshal(m, b)
}
func (m *RowResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_RowResponse.Marshal(b, m, deterministic)
}
func (m *RowResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RowResponse.Merge(m, src)
}
func (m *RowResponse) XXX_Size() int {
	return xxx_messageInfo_RowResponse.Size(m)
}
func (m *RowResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RowResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RowResponse proto.InternalMessageInfo

func (m *RowResponse) GetHeaders() []*ColumnInfo {
	if m != nil {
		return m.Headers
	}
	return nil
}

func (m *RowResponse) GetColumns() []*ColumnResponse {
	if m != nil {
		return m.Columns
	}
	return nil
}

type ColumnInfo struct {
	Name                 string   `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Datatype             string   `protobuf:"bytes,2,opt,name=datatype,proto3" json:"datatype,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ColumnInfo) Reset()         { *m = ColumnInfo{} }
func (m *ColumnInfo) String() string { return proto.CompactTextString(m) }
func (*ColumnInfo) ProtoMessage()    {}
func (*ColumnInfo) Descriptor() ([]byte, []int) {
	return fileDescriptor_ef0691a44d1e275c, []int{2}
}

func (m *ColumnInfo) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ColumnInfo.Unmarshal(m, b)
}
func (m *ColumnInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ColumnInfo.Marshal(b, m, deterministic)
}
func (m *ColumnInfo) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ColumnInfo.Merge(m, src)
}
func (m *ColumnInfo) XXX_Size() int {
	return xxx_messageInfo_ColumnInfo.Size(m)
}
func (m *ColumnInfo) XXX_DiscardUnknown() {
	xxx_messageInfo_ColumnInfo.DiscardUnknown(m)
}

var xxx_messageInfo_ColumnInfo proto.InternalMessageInfo

func (m *ColumnInfo) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *ColumnInfo) GetDatatype() string {
	if m != nil {
		return m.Datatype
	}
	return ""
}

type ColumnResponse struct {
	// Types that are valid to be assigned to ColumnVal:
	//	*ColumnResponse_StringVal
	//	*ColumnResponse_Uint64Val
	//	*ColumnResponse_Int64Val
	//	*ColumnResponse_BoolVal
	//	*ColumnResponse_BlobVal
	//	*ColumnResponse_Uint64ArrayVal
	//	*ColumnResponse_StringArrayVal
	//	*ColumnResponse_Float64Val
	ColumnVal            isColumnResponse_ColumnVal `protobuf_oneof:"columnVal"`
	XXX_NoUnkeyedLiteral struct{}                   `json:"-"`
	XXX_unrecognized     []byte                     `json:"-"`
	XXX_sizecache        int32                      `json:"-"`
}

func (m *ColumnResponse) Reset()         { *m = ColumnResponse{} }
func (m *ColumnResponse) String() string { return proto.CompactTextString(m) }
func (*ColumnResponse) ProtoMessage()    {}
func (*ColumnResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_ef0691a44d1e275c, []int{3}
}

func (m *ColumnResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ColumnResponse.Unmarshal(m, b)
}
func (m *ColumnResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ColumnResponse.Marshal(b, m, deterministic)
}
func (m *ColumnResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ColumnResponse.Merge(m, src)
}
func (m *ColumnResponse) XXX_Size() int {
	return xxx_messageInfo_ColumnResponse.Size(m)
}
func (m *ColumnResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_ColumnResponse.DiscardUnknown(m)
}

var xxx_messageInfo_ColumnResponse proto.InternalMessageInfo

type isColumnResponse_ColumnVal interface {
	isColumnResponse_ColumnVal()
}

type ColumnResponse_StringVal struct {
	StringVal string `protobuf:"bytes,1,opt,name=stringVal,proto3,oneof"`
}

type ColumnResponse_Uint64Val struct {
	Uint64Val uint64 `protobuf:"varint,2,opt,name=uint64Val,proto3,oneof"`
}

type ColumnResponse_Int64Val struct {
	Int64Val int64 `protobuf:"varint,3,opt,name=int64Val,proto3,oneof"`
}

type ColumnResponse_BoolVal struct {
	BoolVal bool `protobuf:"varint,4,opt,name=boolVal,proto3,oneof"`
}

type ColumnResponse_BlobVal struct {
	BlobVal []byte `protobuf:"bytes,5,opt,name=blobVal,proto3,oneof"`
}

type ColumnResponse_Uint64ArrayVal struct {
	Uint64ArrayVal *Uint64Array `protobuf:"bytes,6,opt,name=uint64ArrayVal,proto3,oneof"`
}

type ColumnResponse_StringArrayVal struct {
	StringArrayVal *StringArray `protobuf:"bytes,7,opt,name=stringArrayVal,proto3,oneof"`
}

type ColumnResponse_Float64Val struct {
	Float64Val float64 `protobuf:"fixed64,8,opt,name=float64Val,proto3,oneof"`
}

func (*ColumnResponse_StringVal) isColumnResponse_ColumnVal() {}

func (*ColumnResponse_Uint64Val) isColumnResponse_ColumnVal() {}

func (*ColumnResponse_Int64Val) isColumnResponse_ColumnVal() {}

func (*ColumnResponse_BoolVal) isColumnResponse_ColumnVal() {}

func (*ColumnResponse_BlobVal) isColumnResponse_ColumnVal() {}

func (*ColumnResponse_Uint64ArrayVal) isColumnResponse_ColumnVal() {}

func (*ColumnResponse_StringArrayVal) isColumnResponse_ColumnVal() {}

func (*ColumnResponse_Float64Val) isColumnResponse_ColumnVal() {}

func (m *ColumnResponse) GetColumnVal() isColumnResponse_ColumnVal {
	if m != nil {
		return m.ColumnVal
	}
	return nil
}

func (m *ColumnResponse) GetStringVal() string {
	if x, ok := m.GetColumnVal().(*ColumnResponse_StringVal); ok {
		return x.StringVal
	}
	return ""
}

func (m *ColumnResponse) GetUint64Val() uint64 {
	if x, ok := m.GetColumnVal().(*ColumnResponse_Uint64Val); ok {
		return x.Uint64Val
	}
	return 0
}

func (m *ColumnResponse) GetInt64Val() int64 {
	if x, ok := m.GetColumnVal().(*ColumnResponse_Int64Val); ok {
		return x.Int64Val
	}
	return 0
}

func (m *ColumnResponse) GetBoolVal() bool {
	if x, ok := m.GetColumnVal().(*ColumnResponse_BoolVal); ok {
		return x.BoolVal
	}
	return false
}

func (m *ColumnResponse) GetBlobVal() []byte {
	if x, ok := m.GetColumnVal().(*ColumnResponse_BlobVal); ok {
		return x.BlobVal
	}
	return nil
}

func (m *ColumnResponse) GetUint64ArrayVal() *Uint64Array {
	if x, ok := m.GetColumnVal().(*ColumnResponse_Uint64ArrayVal); ok {
		return x.Uint64ArrayVal
	}
	return nil
}

func (m *ColumnResponse) GetStringArrayVal() *StringArray {
	if x, ok := m.GetColumnVal().(*ColumnResponse_StringArrayVal); ok {
		return x.StringArrayVal
	}
	return nil
}

func (m *ColumnResponse) GetFloat64Val() float64 {
	if x, ok := m.GetColumnVal().(*ColumnResponse_Float64Val); ok {
		return x.Float64Val
	}
	return 0
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*ColumnResponse) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*ColumnResponse_StringVal)(nil),
		(*ColumnResponse_Uint64Val)(nil),
		(*ColumnResponse_Int64Val)(nil),
		(*ColumnResponse_BoolVal)(nil),
		(*ColumnResponse_BlobVal)(nil),
		(*ColumnResponse_Uint64ArrayVal)(nil),
		(*ColumnResponse_StringArrayVal)(nil),
		(*ColumnResponse_Float64Val)(nil),
	}
}

type InspectRequest struct {
	Index                string     `protobuf:"bytes,1,opt,name=index,proto3" json:"index,omitempty"`
	Columns              *IdsOrKeys `protobuf:"bytes,2,opt,name=columns,proto3" json:"columns,omitempty"`
	FilterFields         []string   `protobuf:"bytes,3,rep,name=filterFields,proto3" json:"filterFields,omitempty"`
	XXX_NoUnkeyedLiteral struct{}   `json:"-"`
	XXX_unrecognized     []byte     `json:"-"`
	XXX_sizecache        int32      `json:"-"`
}

func (m *InspectRequest) Reset()         { *m = InspectRequest{} }
func (m *InspectRequest) String() string { return proto.CompactTextString(m) }
func (*InspectRequest) ProtoMessage()    {}
func (*InspectRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_ef0691a44d1e275c, []int{4}
}

func (m *InspectRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_InspectRequest.Unmarshal(m, b)
}
func (m *InspectRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_InspectRequest.Marshal(b, m, deterministic)
}
func (m *InspectRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_InspectRequest.Merge(m, src)
}
func (m *InspectRequest) XXX_Size() int {
	return xxx_messageInfo_InspectRequest.Size(m)
}
func (m *InspectRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_InspectRequest.DiscardUnknown(m)
}

var xxx_messageInfo_InspectRequest proto.InternalMessageInfo

func (m *InspectRequest) GetIndex() string {
	if m != nil {
		return m.Index
	}
	return ""
}

func (m *InspectRequest) GetColumns() *IdsOrKeys {
	if m != nil {
		return m.Columns
	}
	return nil
}

func (m *InspectRequest) GetFilterFields() []string {
	if m != nil {
		return m.FilterFields
	}
	return nil
}

type Uint64Array struct {
	Vals                 []uint64 `protobuf:"varint,1,rep,packed,name=vals,proto3" json:"vals,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *Uint64Array) Reset()         { *m = Uint64Array{} }
func (m *Uint64Array) String() string { return proto.CompactTextString(m) }
func (*Uint64Array) ProtoMessage()    {}
func (*Uint64Array) Descriptor() ([]byte, []int) {
	return fileDescriptor_ef0691a44d1e275c, []int{5}
}

func (m *Uint64Array) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Uint64Array.Unmarshal(m, b)
}
func (m *Uint64Array) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Uint64Array.Marshal(b, m, deterministic)
}
func (m *Uint64Array) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Uint64Array.Merge(m, src)
}
func (m *Uint64Array) XXX_Size() int {
	return xxx_messageInfo_Uint64Array.Size(m)
}
func (m *Uint64Array) XXX_DiscardUnknown() {
	xxx_messageInfo_Uint64Array.DiscardUnknown(m)
}

var xxx_messageInfo_Uint64Array proto.InternalMessageInfo

func (m *Uint64Array) GetVals() []uint64 {
	if m != nil {
		return m.Vals
	}
	return nil
}

type StringArray struct {
	Vals                 []string `protobuf:"bytes,1,rep,name=vals,proto3" json:"vals,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *StringArray) Reset()         { *m = StringArray{} }
func (m *StringArray) String() string { return proto.CompactTextString(m) }
func (*StringArray) ProtoMessage()    {}
func (*StringArray) Descriptor() ([]byte, []int) {
	return fileDescriptor_ef0691a44d1e275c, []int{6}
}

func (m *StringArray) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_StringArray.Unmarshal(m, b)
}
func (m *StringArray) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_StringArray.Marshal(b, m, deterministic)
}
func (m *StringArray) XXX_Merge(src proto.Message) {
	xxx_messageInfo_StringArray.Merge(m, src)
}
func (m *StringArray) XXX_Size() int {
	return xxx_messageInfo_StringArray.Size(m)
}
func (m *StringArray) XXX_DiscardUnknown() {
	xxx_messageInfo_StringArray.DiscardUnknown(m)
}

var xxx_messageInfo_StringArray proto.InternalMessageInfo

func (m *StringArray) GetVals() []string {
	if m != nil {
		return m.Vals
	}
	return nil
}

type IdsOrKeys struct {
	// Types that are valid to be assigned to Type:
	//	*IdsOrKeys_Ids
	//	*IdsOrKeys_Keys
	Type                 isIdsOrKeys_Type `protobuf_oneof:"type"`
	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
	XXX_unrecognized     []byte           `json:"-"`
	XXX_sizecache        int32            `json:"-"`
}

func (m *IdsOrKeys) Reset()         { *m = IdsOrKeys{} }
func (m *IdsOrKeys) String() string { return proto.CompactTextString(m) }
func (*IdsOrKeys) ProtoMessage()    {}
func (*IdsOrKeys) Descriptor() ([]byte, []int) {
	return fileDescriptor_ef0691a44d1e275c, []int{7}
}

func (m *IdsOrKeys) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_IdsOrKeys.Unmarshal(m, b)
}
func (m *IdsOrKeys) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_IdsOrKeys.Marshal(b, m, deterministic)
}
func (m *IdsOrKeys) XXX_Merge(src proto.Message) {
	xxx_messageInfo_IdsOrKeys.Merge(m, src)
}
func (m *IdsOrKeys) XXX_Size() int {
	return xxx_messageInfo_IdsOrKeys.Size(m)
}
func (m *IdsOrKeys) XXX_DiscardUnknown() {
	xxx_messageInfo_IdsOrKeys.DiscardUnknown(m)
}

var xxx_messageInfo_IdsOrKeys proto.InternalMessageInfo

type isIdsOrKeys_Type interface {
	isIdsOrKeys_Type()
}

type IdsOrKeys_Ids struct {
	Ids *Uint64Array `protobuf:"bytes,1,opt,name=ids,proto3,oneof"`
}

type IdsOrKeys_Keys struct {
	Keys *StringArray `protobuf:"bytes,2,opt,name=keys,proto3,oneof"`
}

func (*IdsOrKeys_Ids) isIdsOrKeys_Type() {}

func (*IdsOrKeys_Keys) isIdsOrKeys_Type() {}

func (m *IdsOrKeys) GetType() isIdsOrKeys_Type {
	if m != nil {
		return m.Type
	}
	return nil
}

func (m *IdsOrKeys) GetIds() *Uint64Array {
	if x, ok := m.GetType().(*IdsOrKeys_Ids); ok {
		return x.Ids
	}
	return nil
}

func (m *IdsOrKeys) GetKeys() *StringArray {
	if x, ok := m.GetType().(*IdsOrKeys_Keys); ok {
		return x.Keys
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*IdsOrKeys) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*IdsOrKeys_Ids)(nil),
		(*IdsOrKeys_Keys)(nil),
	}
}

func init() {
	proto.RegisterType((*QueryPQLRequest)(nil), "pilosa.QueryPQLRequest")
	proto.RegisterType((*RowResponse)(nil), "pilosa.RowResponse")
	proto.RegisterType((*ColumnInfo)(nil), "pilosa.ColumnInfo")
	proto.RegisterType((*ColumnResponse)(nil), "pilosa.ColumnResponse")
	proto.RegisterType((*InspectRequest)(nil), "pilosa.InspectRequest")
	proto.RegisterType((*Uint64Array)(nil), "pilosa.Uint64Array")
	proto.RegisterType((*StringArray)(nil), "pilosa.StringArray")
	proto.RegisterType((*IdsOrKeys)(nil), "pilosa.IdsOrKeys")
}

func init() { proto.RegisterFile("pilosa.proto", fileDescriptor_ef0691a44d1e275c) }

var fileDescriptor_ef0691a44d1e275c = []byte{
	// 497 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x7c, 0x53, 0x5d, 0x6b, 0xd4, 0x40,
	0x14, 0xcd, 0x34, 0xe9, 0xee, 0xe6, 0x66, 0x59, 0xf5, 0x2a, 0x1a, 0x16, 0x91, 0x98, 0x17, 0x23,
	0x4a, 0x29, 0xab, 0x08, 0x4a, 0x7d, 0xb0, 0x82, 0x64, 0x51, 0xb0, 0x1d, 0xb1, 0xef, 0xb3, 0xcd,
	0x6c, 0x0d, 0xce, 0x66, 0xd2, 0x4c, 0xd6, 0x9a, 0x57, 0xff, 0xa2, 0x7f, 0x48, 0x66, 0xf2, 0xb1,
	0x49, 0x61, 0x7d, 0x9b, 0x39, 0xe7, 0xdc, 0xef, 0x7b, 0x61, 0x9a, 0xa7, 0x42, 0x2a, 0x76, 0x94,
	0x17, 0xb2, 0x94, 0x38, 0xaa, 0x7f, 0xe1, 0x5b, 0xb8, 0x73, 0xbe, 0xe5, 0x45, 0x75, 0x76, 0xfe,
	0x85, 0xf2, 0xeb, 0x2d, 0x57, 0x25, 0x3e, 0x80, 0xc3, 0x34, 0x4b, 0xf8, 0x6f, 0x9f, 0x04, 0x24,
	0x72, 0x69, 0xfd, 0xc1, 0xbb, 0x60, 0xe7, 0xd7, 0xc2, 0x3f, 0x30, 0x98, 0x7e, 0x86, 0x1b, 0xf0,
	0xa8, 0xbc, 0xa1, 0x5c, 0xe5, 0x32, 0x53, 0x1c, 0x5f, 0xc2, 0xf8, 0x07, 0x67, 0x09, 0x2f, 0x94,
	0x4f, 0x02, 0x3b, 0xf2, 0x16, 0x78, 0xd4, 0x44, 0xfc, 0x28, 0xc5, 0x76, 0x93, 0x2d, 0xb3, 0xb5,
	0xa4, 0xad, 0x04, 0x8f, 0x61, 0x7c, 0x69, 0x60, 0xe5, 0x1f, 0x18, 0xf5, 0xc3, 0xa1, 0xba, 0x75,
	0x4b, 0x5b, 0x59, 0x78, 0x02, 0xb0, 0x73, 0x84, 0x08, 0x4e, 0xc6, 0x36, 0xbc, 0xc9, 0xd1, 0xbc,
	0x71, 0x0e, 0x93, 0x84, 0x95, 0xac, 0xac, 0x72, 0xde, 0xe4, 0xd9, 0xfd, 0xc3, 0xbf, 0x07, 0x30,
	0x1b, 0x7a, 0xc6, 0x27, 0xe0, 0xaa, 0xb2, 0x48, 0xb3, 0xab, 0x0b, 0x26, 0x6a, 0x3f, 0xb1, 0x45,
	0x77, 0x90, 0xe6, 0xb7, 0x69, 0x56, 0xbe, 0x79, 0xad, 0x79, 0xed, 0xcf, 0xd1, 0x7c, 0x07, 0xe1,
	0x63, 0x98, 0x74, 0xb4, 0x1d, 0x90, 0xc8, 0x8e, 0x2d, 0xda, 0x21, 0x38, 0x87, 0xf1, 0x4a, 0x4a,
	0xa1, 0x49, 0x27, 0x20, 0xd1, 0x24, 0xb6, 0x68, 0x0b, 0x18, 0x4e, 0xc8, 0x95, 0xe6, 0x0e, 0x03,
	0x12, 0x4d, 0x0d, 0x57, 0x03, 0xf8, 0x1e, 0x66, 0x75, 0x88, 0x0f, 0x45, 0xc1, 0x2a, 0x2d, 0x19,
	0x05, 0x24, 0xf2, 0x16, 0xf7, 0xdb, 0xfe, 0x7c, 0xdf, 0xb1, 0xb1, 0x45, 0x6f, 0x89, 0xb5, 0x79,
	0x5d, 0x41, 0x67, 0x3e, 0x1e, 0x9a, 0x7f, 0xdb, 0xb1, 0xda, 0x7c, 0x28, 0xc6, 0x00, 0x60, 0x2d,
	0x24, 0x6b, 0xaa, 0x9a, 0x04, 0x24, 0x22, 0xb1, 0x45, 0x7b, 0xd8, 0xa9, 0x07, 0x6e, 0x3d, 0x91,
	0x0b, 0x26, 0xc2, 0x1b, 0x98, 0x2d, 0x33, 0x95, 0xf3, 0xcb, 0xf2, 0xff, 0xcb, 0xf3, 0xa2, 0x3f,
	0x6d, 0x9d, 0xce, 0xbd, 0x36, 0x9d, 0x65, 0xa2, 0xbe, 0x16, 0x9f, 0x79, 0xa5, 0xba, 0x41, 0x63,
	0x08, 0xd3, 0x75, 0x2a, 0x4a, 0x5e, 0x7c, 0x4a, 0xb9, 0x48, 0x94, 0x6f, 0x07, 0x76, 0xe4, 0xd2,
	0x01, 0x16, 0x3e, 0x05, 0xaf, 0xd7, 0x07, 0xbd, 0x0d, 0xbf, 0x98, 0xa8, 0x17, 0xcf, 0xa1, 0xe6,
	0xad, 0x25, 0xbd, 0x5a, 0x07, 0x12, 0xb7, 0x91, 0x5c, 0x81, 0xdb, 0xc5, 0xc7, 0x67, 0x60, 0xa7,
	0x89, 0x32, 0x79, 0xef, 0xed, 0xb6, 0x56, 0xe0, 0x73, 0x70, 0x7e, 0xf2, 0xaa, 0xad, 0x64, 0x4f,
	0x63, 0x8d, 0xe4, 0x74, 0x04, 0x8e, 0xde, 0xbe, 0xc5, 0x1f, 0x02, 0xa3, 0x33, 0x23, 0xc3, 0x13,
	0x98, 0xb4, 0x07, 0x87, 0x8f, 0x5a, 0xdb, 0x5b, 0x27, 0x38, 0xef, 0x9c, 0xf6, 0x0e, 0x2c, 0xb4,
	0x8e, 0x09, 0xbe, 0x83, 0x71, 0xd3, 0x70, 0xec, 0x0e, 0x66, 0x38, 0x81, 0xbd, 0xb6, 0xab, 0x91,
	0xb9, 0xfc, 0x57, 0xff, 0x02, 0x00, 0x00, 0xff, 0xff, 0xca, 0x68, 0x70, 0x08, 0x09, 0x04, 0x00,
	0x00,
}

// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConn

// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion4

// PilosaClient is the client API for Pilosa service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type PilosaClient interface {
	QueryPQL(ctx context.Context, in *QueryPQLRequest, opts ...grpc.CallOption) (Pilosa_QueryPQLClient, error)
	Inspect(ctx context.Context, in *InspectRequest, opts ...grpc.CallOption) (Pilosa_InspectClient, error)
}

type pilosaClient struct {
	cc *grpc.ClientConn
}

func NewPilosaClient(cc *grpc.ClientConn) PilosaClient {
	return &pilosaClient{cc}
}

func (c *pilosaClient) QueryPQL(ctx context.Context, in *QueryPQLRequest, opts ...grpc.CallOption) (Pilosa_QueryPQLClient, error) {
	stream, err := c.cc.NewStream(ctx, &_Pilosa_serviceDesc.Streams[0], "/pilosa.Pilosa/QueryPQL", opts...)
	if err != nil {
		return nil, err
	}
	x := &pilosaQueryPQLClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type Pilosa_QueryPQLClient interface {
	Recv() (*RowResponse, error)
	grpc.ClientStream
}

type pilosaQueryPQLClient struct {
	grpc.ClientStream
}

func (x *pilosaQueryPQLClient) Recv() (*RowResponse, error) {
	m := new(RowResponse)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *pilosaClient) Inspect(ctx context.Context, in *InspectRequest, opts ...grpc.CallOption) (Pilosa_InspectClient, error) {
	stream, err := c.cc.NewStream(ctx, &_Pilosa_serviceDesc.Streams[1], "/pilosa.Pilosa/Inspect", opts...)
	if err != nil {
		return nil, err
	}
	x := &pilosaInspectClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type Pilosa_InspectClient interface {
	Recv() (*RowResponse, error)
	grpc.ClientStream
}

type pilosaInspectClient struct {
	grpc.ClientStream
}

func (x *pilosaInspectClient) Recv() (*RowResponse, error) {
	m := new(RowResponse)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

// PilosaServer is the server API for Pilosa service.
type PilosaServer interface {
	QueryPQL(*QueryPQLRequest, Pilosa_QueryPQLServer) error
	Inspect(*InspectRequest, Pilosa_InspectServer) error
}

// UnimplementedPilosaServer can be embedded to have forward compatible implementations.
type UnimplementedPilosaServer struct {
}

func (*UnimplementedPilosaServer) QueryPQL(req *QueryPQLRequest, srv Pilosa_QueryPQLServer) error {
	return status.Errorf(codes.Unimplemented, "method QueryPQL not implemented")
}
func (*UnimplementedPilosaServer) Inspect(req *InspectRequest, srv Pilosa_InspectServer) error {
	return status.Errorf(codes.Unimplemented, "method Inspect not implemented")
}

func RegisterPilosaServer(s *grpc.Server, srv PilosaServer) {
	s.RegisterService(&_Pilosa_serviceDesc, srv)
}

func _Pilosa_QueryPQL_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(QueryPQLRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(PilosaServer).QueryPQL(m, &pilosaQueryPQLServer{stream})
}

type Pilosa_QueryPQLServer interface {
	Send(*RowResponse) error
	grpc.ServerStream
}

type pilosaQueryPQLServer struct {
	grpc.ServerStream
}

func (x *pilosaQueryPQLServer) Send(m *RowResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _Pilosa_Inspect_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(InspectRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(PilosaServer).Inspect(m, &pilosaInspectServer{stream})
}

type Pilosa_InspectServer interface {
	Send(*RowResponse) error
	grpc.ServerStream
}

type pilosaInspectServer struct {
	grpc.ServerStream
}

func (x *pilosaInspectServer) Send(m *RowResponse) error {
	return x.ServerStream.SendMsg(m)
}

var _Pilosa_serviceDesc = grpc.ServiceDesc{
	ServiceName: "pilosa.Pilosa",
	HandlerType: (*PilosaServer)(nil),
	Methods:     []grpc.MethodDesc{},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "QueryPQL",
			Handler:       _Pilosa_QueryPQL_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "Inspect",
			Handler:       _Pilosa_Inspect_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "pilosa.proto",
}