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

package proto

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 QuerySQLRequest struct {
	Sql                  string   `protobuf:"bytes,1,opt,name=sql,proto3" json:"sql,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_QuerySQLRequest proto.InternalMessageInfo

func (m *QuerySQLRequest) GetSql() string {
	if m != nil {
		return m.Sql
	}
	return ""
}

type StatusError struct {
	Code                 uint32   `protobuf:"varint,1,opt,name=Code,proto3" json:"Code,omitempty"`
	Message              string   `protobuf:"bytes,2,opt,name=Message,proto3" json:"Message,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_StatusError proto.InternalMessageInfo

func (m *StatusError) GetCode() uint32 {
	if m != nil {
		return m.Code
	}
	return 0
}

func (m *StatusError) GetMessage() string {
	if m != nil {
		return m.Message
	}
	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"`
	StatusError          *StatusError      `protobuf:"bytes,3,opt,name=StatusError,proto3" json:"StatusError,omitempty"`
	Duration             int64             `protobuf:"varint,4,opt,name=duration,proto3" json:"duration,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{3}
}

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
}

func (m *RowResponse) GetStatusError() *StatusError {
	if m != nil {
		return m.StatusError
	}
	return nil
}

func (m *RowResponse) GetDuration() int64 {
	if m != nil {
		return m.Duration
	}
	return 0
}

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

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

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

var xxx_messageInfo_Row proto.InternalMessageInfo

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

type TableResponse struct {
	Headers              []*ColumnInfo `protobuf:"bytes,1,rep,name=headers,proto3" json:"headers,omitempty"`
	Rows                 []*Row        `protobuf:"bytes,2,rep,name=rows,proto3" json:"rows,omitempty"`
	StatusError          *StatusError  `protobuf:"bytes,3,opt,name=StatusError,proto3" json:"StatusError,omitempty"`
	Duration             int64         `protobuf:"varint,4,opt,name=duration,proto3" json:"duration,omitempty"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
	XXX_unrecognized     []byte        `json:"-"`
	XXX_sizecache        int32         `json:"-"`
}

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

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

var xxx_messageInfo_TableResponse proto.InternalMessageInfo

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

func (m *TableResponse) GetRows() []*Row {
	if m != nil {
		return m.Rows
	}
	return nil
}

func (m *TableResponse) GetStatusError() *StatusError {
	if m != nil {
		return m.StatusError
	}
	return nil
}

func (m *TableResponse) GetDuration() int64 {
	if m != nil {
		return m.Duration
	}
	return 0
}

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{6}
}

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
	//	*ColumnResponse_DecimalVal
	//	*ColumnResponse_TimestampVal
	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{7}
}

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"`
}

type ColumnResponse_DecimalVal struct {
	DecimalVal *Decimal `protobuf:"bytes,9,opt,name=decimalVal,proto3,oneof"`
}

type ColumnResponse_TimestampVal struct {
	TimestampVal string `protobuf:"bytes,10,opt,name=timestampVal,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 (*ColumnResponse_DecimalVal) isColumnResponse_ColumnVal() {}

func (*ColumnResponse_TimestampVal) 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
}

func (m *ColumnResponse) GetDecimalVal() *Decimal {
	if x, ok := m.GetColumnVal().(*ColumnResponse_DecimalVal); ok {
		return x.DecimalVal
	}
	return nil
}

func (m *ColumnResponse) GetTimestampVal() string {
	if x, ok := m.GetColumnVal().(*ColumnResponse_TimestampVal); ok {
		return x.TimestampVal
	}
	return ""
}

// 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),
		(*ColumnResponse_DecimalVal)(nil),
		(*ColumnResponse_TimestampVal)(nil),
	}
}

type Decimal struct {
	Value                int64    `protobuf:"varint,1,opt,name=value,proto3" json:"value,omitempty"`
	Scale                int64    `protobuf:"varint,2,opt,name=scale,proto3" json:"scale,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_Decimal proto.InternalMessageInfo

func (m *Decimal) GetValue() int64 {
	if m != nil {
		return m.Value
	}
	return 0
}

func (m *Decimal) GetScale() int64 {
	if m != nil {
		return m.Scale
	}
	return 0
}

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"`
	Limit                uint64     `protobuf:"varint,4,opt,name=limit,proto3" json:"limit,omitempty"`
	Offset               uint64     `protobuf:"varint,5,opt,name=offset,proto3" json:"offset,omitempty"`
	Query                string     `protobuf:"bytes,6,opt,name=query,proto3" json:"query,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{9}
}

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
}

func (m *InspectRequest) GetLimit() uint64 {
	if m != nil {
		return m.Limit
	}
	return 0
}

func (m *InspectRequest) GetOffset() uint64 {
	if m != nil {
		return m.Offset
	}
	return 0
}

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

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{10}
}

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{11}
}

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{12}
}

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),
	}
}

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

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

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

var xxx_messageInfo_Index proto.InternalMessageInfo

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

type CreateIndexRequest struct {
	Name                 string   `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Keys                 bool     `protobuf:"varint,2,opt,name=keys,proto3" json:"keys,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_CreateIndexRequest proto.InternalMessageInfo

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

func (m *CreateIndexRequest) GetKeys() bool {
	if m != nil {
		return m.Keys
	}
	return false
}

type CreateIndexResponse struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_CreateIndexResponse proto.InternalMessageInfo

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

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

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

var xxx_messageInfo_GetIndexRequest proto.InternalMessageInfo

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

type GetIndexResponse struct {
	Index                *Index   `protobuf:"bytes,1,opt,name=index,proto3" json:"index,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_GetIndexResponse proto.InternalMessageInfo

func (m *GetIndexResponse) GetIndex() *Index {
	if m != nil {
		return m.Index
	}
	return nil
}

type GetIndexesRequest struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_GetIndexesRequest proto.InternalMessageInfo

type GetIndexesResponse struct {
	Indexes              []*Index `protobuf:"bytes,1,rep,name=indexes,proto3" json:"indexes,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_GetIndexesResponse proto.InternalMessageInfo

func (m *GetIndexesResponse) GetIndexes() []*Index {
	if m != nil {
		return m.Indexes
	}
	return nil
}

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

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

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

var xxx_messageInfo_DeleteIndexRequest proto.InternalMessageInfo

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

type DeleteIndexResponse struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_DeleteIndexResponse proto.InternalMessageInfo

func init() {
	proto.RegisterType((*QueryPQLRequest)(nil), "pilosa.QueryPQLRequest")
	proto.RegisterType((*QuerySQLRequest)(nil), "pilosa.QuerySQLRequest")
	proto.RegisterType((*StatusError)(nil), "pilosa.StatusError")
	proto.RegisterType((*RowResponse)(nil), "pilosa.RowResponse")
	proto.RegisterType((*Row)(nil), "pilosa.Row")
	proto.RegisterType((*TableResponse)(nil), "pilosa.TableResponse")
	proto.RegisterType((*ColumnInfo)(nil), "pilosa.ColumnInfo")
	proto.RegisterType((*ColumnResponse)(nil), "pilosa.ColumnResponse")
	proto.RegisterType((*Decimal)(nil), "pilosa.Decimal")
	proto.RegisterType((*InspectRequest)(nil), "pilosa.InspectRequest")
	proto.RegisterType((*Uint64Array)(nil), "pilosa.Uint64Array")
	proto.RegisterType((*StringArray)(nil), "pilosa.StringArray")
	proto.RegisterType((*IdsOrKeys)(nil), "pilosa.IdsOrKeys")
	proto.RegisterType((*Index)(nil), "pilosa.Index")
	proto.RegisterType((*CreateIndexRequest)(nil), "pilosa.CreateIndexRequest")
	proto.RegisterType((*CreateIndexResponse)(nil), "pilosa.CreateIndexResponse")
	proto.RegisterType((*GetIndexRequest)(nil), "pilosa.GetIndexRequest")
	proto.RegisterType((*GetIndexResponse)(nil), "pilosa.GetIndexResponse")
	proto.RegisterType((*GetIndexesRequest)(nil), "pilosa.GetIndexesRequest")
	proto.RegisterType((*GetIndexesResponse)(nil), "pilosa.GetIndexesResponse")
	proto.RegisterType((*DeleteIndexRequest)(nil), "pilosa.DeleteIndexRequest")
	proto.RegisterType((*DeleteIndexResponse)(nil), "pilosa.DeleteIndexResponse")
}

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

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

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

// 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.SupportPackageIsVersion6

// 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 {
	CreateIndex(ctx context.Context, in *CreateIndexRequest, opts ...grpc.CallOption) (*CreateIndexResponse, error)
	GetIndexes(ctx context.Context, in *GetIndexesRequest, opts ...grpc.CallOption) (*GetIndexesResponse, error)
	GetIndex(ctx context.Context, in *GetIndexRequest, opts ...grpc.CallOption) (*GetIndexResponse, error)
	DeleteIndex(ctx context.Context, in *DeleteIndexRequest, opts ...grpc.CallOption) (*DeleteIndexResponse, error)
	QuerySQL(ctx context.Context, in *QuerySQLRequest, opts ...grpc.CallOption) (Pilosa_QuerySQLClient, error)
	QuerySQLUnary(ctx context.Context, in *QuerySQLRequest, opts ...grpc.CallOption) (*TableResponse, error)
	QueryPQL(ctx context.Context, in *QueryPQLRequest, opts ...grpc.CallOption) (Pilosa_QueryPQLClient, error)
	QueryPQLUnary(ctx context.Context, in *QueryPQLRequest, opts ...grpc.CallOption) (*TableResponse, error)
	Inspect(ctx context.Context, in *InspectRequest, opts ...grpc.CallOption) (Pilosa_InspectClient, error)
}

type pilosaClient struct {
	cc grpc.ClientConnInterface
}

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

func (c *pilosaClient) CreateIndex(ctx context.Context, in *CreateIndexRequest, opts ...grpc.CallOption) (*CreateIndexResponse, error) {
	out := new(CreateIndexResponse)
	err := c.cc.Invoke(ctx, "/pilosa.Pilosa/CreateIndex", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *pilosaClient) GetIndexes(ctx context.Context, in *GetIndexesRequest, opts ...grpc.CallOption) (*GetIndexesResponse, error) {
	out := new(GetIndexesResponse)
	err := c.cc.Invoke(ctx, "/pilosa.Pilosa/GetIndexes", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *pilosaClient) GetIndex(ctx context.Context, in *GetIndexRequest, opts ...grpc.CallOption) (*GetIndexResponse, error) {
	out := new(GetIndexResponse)
	err := c.cc.Invoke(ctx, "/pilosa.Pilosa/GetIndex", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *pilosaClient) DeleteIndex(ctx context.Context, in *DeleteIndexRequest, opts ...grpc.CallOption) (*DeleteIndexResponse, error) {
	out := new(DeleteIndexResponse)
	err := c.cc.Invoke(ctx, "/pilosa.Pilosa/DeleteIndex", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *pilosaClient) QuerySQL(ctx context.Context, in *QuerySQLRequest, opts ...grpc.CallOption) (Pilosa_QuerySQLClient, error) {
	stream, err := c.cc.NewStream(ctx, &_Pilosa_serviceDesc.Streams[0], "/pilosa.Pilosa/QuerySQL", opts...)
	if err != nil {
		return nil, err
	}
	x := &pilosaQuerySQLClient{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_QuerySQLClient interface {
	Recv() (*RowResponse, error)
	grpc.ClientStream
}

type pilosaQuerySQLClient struct {
	grpc.ClientStream
}

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

func (c *pilosaClient) QuerySQLUnary(ctx context.Context, in *QuerySQLRequest, opts ...grpc.CallOption) (*TableResponse, error) {
	out := new(TableResponse)
	err := c.cc.Invoke(ctx, "/pilosa.Pilosa/QuerySQLUnary", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *pilosaClient) QueryPQL(ctx context.Context, in *QueryPQLRequest, opts ...grpc.CallOption) (Pilosa_QueryPQLClient, error) {
	stream, err := c.cc.NewStream(ctx, &_Pilosa_serviceDesc.Streams[1], "/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) QueryPQLUnary(ctx context.Context, in *QueryPQLRequest, opts ...grpc.CallOption) (*TableResponse, error) {
	out := new(TableResponse)
	err := c.cc.Invoke(ctx, "/pilosa.Pilosa/QueryPQLUnary", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, 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[2], "/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 {
	CreateIndex(context.Context, *CreateIndexRequest) (*CreateIndexResponse, error)
	GetIndexes(context.Context, *GetIndexesRequest) (*GetIndexesResponse, error)
	GetIndex(context.Context, *GetIndexRequest) (*GetIndexResponse, error)
	DeleteIndex(context.Context, *DeleteIndexRequest) (*DeleteIndexResponse, error)
	QuerySQL(*QuerySQLRequest, Pilosa_QuerySQLServer) error
	QuerySQLUnary(context.Context, *QuerySQLRequest) (*TableResponse, error)
	QueryPQL(*QueryPQLRequest, Pilosa_QueryPQLServer) error
	QueryPQLUnary(context.Context, *QueryPQLRequest) (*TableResponse, error)
	Inspect(*InspectRequest, Pilosa_InspectServer) error
}

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

func (*UnimplementedPilosaServer) CreateIndex(ctx context.Context, req *CreateIndexRequest) (*CreateIndexResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CreateIndex not implemented")
}
func (*UnimplementedPilosaServer) GetIndexes(ctx context.Context, req *GetIndexesRequest) (*GetIndexesResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetIndexes not implemented")
}
func (*UnimplementedPilosaServer) GetIndex(ctx context.Context, req *GetIndexRequest) (*GetIndexResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetIndex not implemented")
}
func (*UnimplementedPilosaServer) DeleteIndex(ctx context.Context, req *DeleteIndexRequest) (*DeleteIndexResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeleteIndex not implemented")
}
func (*UnimplementedPilosaServer) QuerySQL(req *QuerySQLRequest, srv Pilosa_QuerySQLServer) error {
	return status.Errorf(codes.Unimplemented, "method QuerySQL not implemented")
}
func (*UnimplementedPilosaServer) QuerySQLUnary(ctx context.Context, req *QuerySQLRequest) (*TableResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method QuerySQLUnary not implemented")
}
func (*UnimplementedPilosaServer) QueryPQL(req *QueryPQLRequest, srv Pilosa_QueryPQLServer) error {
	return status.Errorf(codes.Unimplemented, "method QueryPQL not implemented")
}
func (*UnimplementedPilosaServer) QueryPQLUnary(ctx context.Context, req *QueryPQLRequest) (*TableResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method QueryPQLUnary 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_CreateIndex_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CreateIndexRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(PilosaServer).CreateIndex(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/pilosa.Pilosa/CreateIndex",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(PilosaServer).CreateIndex(ctx, req.(*CreateIndexRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Pilosa_GetIndexes_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetIndexesRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(PilosaServer).GetIndexes(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/pilosa.Pilosa/GetIndexes",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(PilosaServer).GetIndexes(ctx, req.(*GetIndexesRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Pilosa_GetIndex_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetIndexRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(PilosaServer).GetIndex(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/pilosa.Pilosa/GetIndex",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(PilosaServer).GetIndex(ctx, req.(*GetIndexRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Pilosa_DeleteIndex_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DeleteIndexRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(PilosaServer).DeleteIndex(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/pilosa.Pilosa/DeleteIndex",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(PilosaServer).DeleteIndex(ctx, req.(*DeleteIndexRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Pilosa_QuerySQL_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(QuerySQLRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(PilosaServer).QuerySQL(m, &pilosaQuerySQLServer{stream})
}

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

type pilosaQuerySQLServer struct {
	grpc.ServerStream
}

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

func _Pilosa_QuerySQLUnary_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QuerySQLRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(PilosaServer).QuerySQLUnary(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/pilosa.Pilosa/QuerySQLUnary",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(PilosaServer).QuerySQLUnary(ctx, req.(*QuerySQLRequest))
	}
	return interceptor(ctx, in, info, handler)
}

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_QueryPQLUnary_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryPQLRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(PilosaServer).QueryPQLUnary(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/pilosa.Pilosa/QueryPQLUnary",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(PilosaServer).QueryPQLUnary(ctx, req.(*QueryPQLRequest))
	}
	return interceptor(ctx, in, info, handler)
}

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{
		{
			MethodName: "CreateIndex",
			Handler:    _Pilosa_CreateIndex_Handler,
		},
		{
			MethodName: "GetIndexes",
			Handler:    _Pilosa_GetIndexes_Handler,
		},
		{
			MethodName: "GetIndex",
			Handler:    _Pilosa_GetIndex_Handler,
		},
		{
			MethodName: "DeleteIndex",
			Handler:    _Pilosa_DeleteIndex_Handler,
		},
		{
			MethodName: "QuerySQLUnary",
			Handler:    _Pilosa_QuerySQLUnary_Handler,
		},
		{
			MethodName: "QueryPQLUnary",
			Handler:    _Pilosa_QueryPQLUnary_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "QuerySQL",
			Handler:       _Pilosa_QuerySQL_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "QueryPQL",
			Handler:       _Pilosa_QueryPQL_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "Inspect",
			Handler:       _Pilosa_Inspect_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "pilosa.proto",
}
