golsql

type Comparator int32

type DataSourceClient interface {
	Execute(ctx context.Context, in *Query, opts ...grpc.CallOption) (*Result, error)
	ExecuteBatch(ctx context.Context, opts ...grpc.CallOption) (DataSource_ExecuteBatchClient, error)
}

type DataSourceServer interface {
	Execute(context.Context, *Query) (*Result, error)
	ExecuteBatch(DataSource_ExecuteBatchServer) error
	// contains filtered or unexported methods
}

type DataSource_ExecuteBatchClient interface {
	Send(*Query) error
	Recv() (*StreamResult, error)
	grpc.ClientStream
}

type DataSource_ExecuteBatchServer interface {
	Send(*StreamResult) error
	Recv() (*Query, error)
	grpc.ServerStream
}

type DomainJoins struct {
	// contains filtered or unexported fields
}

type GroupOperator int32

type Ordering struct {

	// Priority must be set to a unique value if ordering is present for an item, duplicate priorities within a request is considered an error
	Priority   uint32 `protobuf:"varint,1,opt,name=priority,proto3" json:"priority,omitempty"`
	Descending bool   `protobuf:"varint,2,opt,name=descending,proto3" json:"descending,omitempty"`
	// contains filtered or unexported fields
}

type Paging struct {
	Limit  uint64 `protobuf:"varint,1,opt,name=limit,proto3" json:"limit,omitempty"`
	Offset uint64 `protobuf:"varint,2,opt,name=offset,proto3" json:"offset,omitempty"`
	// contains filtered or unexported fields
}

type Query struct {

	// A UUID generated for this query for idempotence and caching reasons, must be non-empty.
	// Repeated values may have their contents ignored by the server if it chooses to return cached content.
	// Servers must still correctly obey authC and authZ logic when choosing to return cached content based on ID.
	Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	// Types that are assignable to DomainSpace:
	//	*Query_Domain
	DomainSpace isQuery_DomainSpace `protobuf_oneof:"domain_space"`
	Paging      *Paging             `protobuf:"bytes,2,opt,name=paging,proto3" json:"paging,omitempty"`
	Where       *WhereGroup         `protobuf:"bytes,3,opt,name=where,proto3" json:"where,omitempty"`
	// contains filtered or unexported fields
}

type Query_Domain struct {
	Domain string `protobuf:"bytes,101,opt,name=domain,proto3,oneof"` // DomainJoins domains = 102; // TODO
}

type Result struct {
	Data []*_struct.Struct `protobuf:"bytes,1,rep,name=data,proto3" json:"data,omitempty"`
	// contains filtered or unexported fields
}

type StreamResult struct {

	// ID allows mapping of streamed results back to streamed requests
	Id   string            `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Data []*_struct.Struct `protobuf:"bytes,2,rep,name=data,proto3" json:"data,omitempty"`
	// contains filtered or unexported fields
}

type UnimplementedDataSourceServer struct {
}

type UnsafeDataSourceServer interface {
	// contains filtered or unexported methods
}

type WhereField struct {
	FieldName        string     `protobuf:"bytes,1,opt,name=field_name,json=fieldName,proto3" json:"field_name,omitempty"`
	NegateComparator bool       `protobuf:"varint,2,opt,name=negate_comparator,json=negateComparator,proto3" json:"negate_comparator,omitempty"`
	Comparator       Comparator `protobuf:"varint,3,opt,name=comparator,proto3,enum=Comparator" json:"comparator,omitempty"`
	// DomainName is optional if only one domain is present, but mandatory if multiple domains are present
	DomainName string `protobuf:"bytes,4,opt,name=domain_name,json=domainName,proto3" json:"domain_name,omitempty"`
	// Types that are assignable to Value:
	//	*WhereField_StringValue
	//	*WhereField_Int64Value
	//	*WhereField_Uint64Value
	//	*WhereField_DoubleValue
	//	*WhereField_BoolValue
	//	*WhereField_BytesValue
	//	*WhereField_TimeValue
	Value isWhereField_Value `protobuf_oneof:"value"`
	// Ordering is optional, unless the RDBMS on the other end requires it,
	// but it is the responsibility of the server directly interfacing with the RDBMS to understand the requirements of its data source.
	Ordering *Ordering `protobuf:"bytes,5,opt,name=ordering,proto3" json:"ordering,omitempty"`
	// contains filtered or unexported fields
}

type WhereField_BoolValue struct {
	BoolValue bool `protobuf:"varint,105,opt,name=bool_value,json=boolValue,proto3,oneof"`
}

type WhereField_BytesValue struct {
	BytesValue []byte `protobuf:"bytes,106,opt,name=bytes_value,json=bytesValue,proto3,oneof"`
}

type WhereField_DoubleValue struct {
	DoubleValue float64 `protobuf:"fixed64,104,opt,name=double_value,json=doubleValue,proto3,oneof"`
}

type WhereField_Int64Value struct {
	Int64Value int64 `protobuf:"varint,102,opt,name=int64_value,json=int64Value,proto3,oneof"`
}

type WhereField_StringValue struct {
	StringValue string `protobuf:"bytes,101,opt,name=string_value,json=stringValue,proto3,oneof"`
}

type WhereField_TimeValue struct {
	TimeValue *timestamp.Timestamp `protobuf:"bytes,107,opt,name=time_value,json=timeValue,proto3,oneof"` // TODO: other basic types I'm forgetting?
}

type WhereField_Uint64Value struct {
	Uint64Value uint64 `protobuf:"varint,103,opt,name=uint64_value,json=uint64Value,proto3,oneof"`
}

type WhereGroup struct {
	Elements       []*WhereGroupElement `protobuf:"bytes,1,rep,name=elements,proto3" json:"elements,omitempty"`
	NegateOperator bool                 `protobuf:"varint,2,opt,name=negate_operator,json=negateOperator,proto3" json:"negate_operator,omitempty"`
	Operator       GroupOperator        `protobuf:"varint,3,opt,name=operator,proto3,enum=GroupOperator" json:"operator,omitempty"`
	// contains filtered or unexported fields
}

type WhereGroupElement struct {

	// Types that are assignable to Element:
	//	*WhereGroupElement_Field
	//	*WhereGroupElement_Group
	Element isWhereGroupElement_Element `protobuf_oneof:"element"`
	// contains filtered or unexported fields
}

type WhereGroupElement_Field struct {
	Field *WhereField `protobuf:"bytes,101,opt,name=field,proto3,oneof"`
}

type WhereGroupElement_Group struct {
	Group *WhereGroup `protobuf:"bytes,102,opt,name=group,proto3,oneof"`
}