| // Code generated by protoc-gen-go. |
| // source: datastore_v1.proto |
| // DO NOT EDIT! |
| |
| /* |
| Package datastore is a generated protocol buffer package. |
| |
| It is generated from these files: |
| datastore_v1.proto |
| |
| It has these top-level messages: |
| PartitionId |
| Key |
| Value |
| Property |
| Entity |
| EntityResult |
| Query |
| KindExpression |
| PropertyReference |
| PropertyExpression |
| PropertyOrder |
| Filter |
| CompositeFilter |
| PropertyFilter |
| GqlQuery |
| GqlQueryArg |
| QueryResultBatch |
| Mutation |
| MutationResult |
| ReadOptions |
| LookupRequest |
| LookupResponse |
| RunQueryRequest |
| RunQueryResponse |
| BeginTransactionRequest |
| BeginTransactionResponse |
| RollbackRequest |
| RollbackResponse |
| CommitRequest |
| CommitResponse |
| AllocateIdsRequest |
| AllocateIdsResponse |
| */ |
| package datastore |
| |
| import proto "github.com/golang/protobuf/proto" |
| import math "math" |
| |
| // Reference imports to suppress errors if they are not otherwise used. |
| var _ = proto.Marshal |
| var _ = math.Inf |
| |
| // Specifies what data the 'entity' field contains. |
| // A ResultType is either implied (for example, in LookupResponse.found it |
| // is always FULL) or specified by context (for example, in message |
| // QueryResultBatch, field 'entity_result_type' specifies a ResultType |
| // for all the values in field 'entity_result'). |
| type EntityResult_ResultType int32 |
| |
| const ( |
| EntityResult_FULL EntityResult_ResultType = 1 |
| EntityResult_PROJECTION EntityResult_ResultType = 2 |
| // The entity may have no key. |
| // A property value may have meaning 18. |
| EntityResult_KEY_ONLY EntityResult_ResultType = 3 |
| ) |
| |
| var EntityResult_ResultType_name = map[int32]string{ |
| 1: "FULL", |
| 2: "PROJECTION", |
| 3: "KEY_ONLY", |
| } |
| var EntityResult_ResultType_value = map[string]int32{ |
| "FULL": 1, |
| "PROJECTION": 2, |
| "KEY_ONLY": 3, |
| } |
| |
| func (x EntityResult_ResultType) Enum() *EntityResult_ResultType { |
| p := new(EntityResult_ResultType) |
| *p = x |
| return p |
| } |
| func (x EntityResult_ResultType) String() string { |
| return proto.EnumName(EntityResult_ResultType_name, int32(x)) |
| } |
| func (x *EntityResult_ResultType) UnmarshalJSON(data []byte) error { |
| value, err := proto.UnmarshalJSONEnum(EntityResult_ResultType_value, data, "EntityResult_ResultType") |
| if err != nil { |
| return err |
| } |
| *x = EntityResult_ResultType(value) |
| return nil |
| } |
| |
| type PropertyExpression_AggregationFunction int32 |
| |
| const ( |
| PropertyExpression_FIRST PropertyExpression_AggregationFunction = 1 |
| ) |
| |
| var PropertyExpression_AggregationFunction_name = map[int32]string{ |
| 1: "FIRST", |
| } |
| var PropertyExpression_AggregationFunction_value = map[string]int32{ |
| "FIRST": 1, |
| } |
| |
| func (x PropertyExpression_AggregationFunction) Enum() *PropertyExpression_AggregationFunction { |
| p := new(PropertyExpression_AggregationFunction) |
| *p = x |
| return p |
| } |
| func (x PropertyExpression_AggregationFunction) String() string { |
| return proto.EnumName(PropertyExpression_AggregationFunction_name, int32(x)) |
| } |
| func (x *PropertyExpression_AggregationFunction) UnmarshalJSON(data []byte) error { |
| value, err := proto.UnmarshalJSONEnum(PropertyExpression_AggregationFunction_value, data, "PropertyExpression_AggregationFunction") |
| if err != nil { |
| return err |
| } |
| *x = PropertyExpression_AggregationFunction(value) |
| return nil |
| } |
| |
| type PropertyOrder_Direction int32 |
| |
| const ( |
| PropertyOrder_ASCENDING PropertyOrder_Direction = 1 |
| PropertyOrder_DESCENDING PropertyOrder_Direction = 2 |
| ) |
| |
| var PropertyOrder_Direction_name = map[int32]string{ |
| 1: "ASCENDING", |
| 2: "DESCENDING", |
| } |
| var PropertyOrder_Direction_value = map[string]int32{ |
| "ASCENDING": 1, |
| "DESCENDING": 2, |
| } |
| |
| func (x PropertyOrder_Direction) Enum() *PropertyOrder_Direction { |
| p := new(PropertyOrder_Direction) |
| *p = x |
| return p |
| } |
| func (x PropertyOrder_Direction) String() string { |
| return proto.EnumName(PropertyOrder_Direction_name, int32(x)) |
| } |
| func (x *PropertyOrder_Direction) UnmarshalJSON(data []byte) error { |
| value, err := proto.UnmarshalJSONEnum(PropertyOrder_Direction_value, data, "PropertyOrder_Direction") |
| if err != nil { |
| return err |
| } |
| *x = PropertyOrder_Direction(value) |
| return nil |
| } |
| |
| type CompositeFilter_Operator int32 |
| |
| const ( |
| CompositeFilter_AND CompositeFilter_Operator = 1 |
| ) |
| |
| var CompositeFilter_Operator_name = map[int32]string{ |
| 1: "AND", |
| } |
| var CompositeFilter_Operator_value = map[string]int32{ |
| "AND": 1, |
| } |
| |
| func (x CompositeFilter_Operator) Enum() *CompositeFilter_Operator { |
| p := new(CompositeFilter_Operator) |
| *p = x |
| return p |
| } |
| func (x CompositeFilter_Operator) String() string { |
| return proto.EnumName(CompositeFilter_Operator_name, int32(x)) |
| } |
| func (x *CompositeFilter_Operator) UnmarshalJSON(data []byte) error { |
| value, err := proto.UnmarshalJSONEnum(CompositeFilter_Operator_value, data, "CompositeFilter_Operator") |
| if err != nil { |
| return err |
| } |
| *x = CompositeFilter_Operator(value) |
| return nil |
| } |
| |
| type PropertyFilter_Operator int32 |
| |
| const ( |
| PropertyFilter_LESS_THAN PropertyFilter_Operator = 1 |
| PropertyFilter_LESS_THAN_OR_EQUAL PropertyFilter_Operator = 2 |
| PropertyFilter_GREATER_THAN PropertyFilter_Operator = 3 |
| PropertyFilter_GREATER_THAN_OR_EQUAL PropertyFilter_Operator = 4 |
| PropertyFilter_EQUAL PropertyFilter_Operator = 5 |
| PropertyFilter_HAS_ANCESTOR PropertyFilter_Operator = 11 |
| ) |
| |
| var PropertyFilter_Operator_name = map[int32]string{ |
| 1: "LESS_THAN", |
| 2: "LESS_THAN_OR_EQUAL", |
| 3: "GREATER_THAN", |
| 4: "GREATER_THAN_OR_EQUAL", |
| 5: "EQUAL", |
| 11: "HAS_ANCESTOR", |
| } |
| var PropertyFilter_Operator_value = map[string]int32{ |
| "LESS_THAN": 1, |
| "LESS_THAN_OR_EQUAL": 2, |
| "GREATER_THAN": 3, |
| "GREATER_THAN_OR_EQUAL": 4, |
| "EQUAL": 5, |
| "HAS_ANCESTOR": 11, |
| } |
| |
| func (x PropertyFilter_Operator) Enum() *PropertyFilter_Operator { |
| p := new(PropertyFilter_Operator) |
| *p = x |
| return p |
| } |
| func (x PropertyFilter_Operator) String() string { |
| return proto.EnumName(PropertyFilter_Operator_name, int32(x)) |
| } |
| func (x *PropertyFilter_Operator) UnmarshalJSON(data []byte) error { |
| value, err := proto.UnmarshalJSONEnum(PropertyFilter_Operator_value, data, "PropertyFilter_Operator") |
| if err != nil { |
| return err |
| } |
| *x = PropertyFilter_Operator(value) |
| return nil |
| } |
| |
| // The possible values for the 'more_results' field. |
| type QueryResultBatch_MoreResultsType int32 |
| |
| const ( |
| QueryResultBatch_NOT_FINISHED QueryResultBatch_MoreResultsType = 1 |
| QueryResultBatch_MORE_RESULTS_AFTER_LIMIT QueryResultBatch_MoreResultsType = 2 |
| // results after the limit. |
| QueryResultBatch_NO_MORE_RESULTS QueryResultBatch_MoreResultsType = 3 |
| ) |
| |
| var QueryResultBatch_MoreResultsType_name = map[int32]string{ |
| 1: "NOT_FINISHED", |
| 2: "MORE_RESULTS_AFTER_LIMIT", |
| 3: "NO_MORE_RESULTS", |
| } |
| var QueryResultBatch_MoreResultsType_value = map[string]int32{ |
| "NOT_FINISHED": 1, |
| "MORE_RESULTS_AFTER_LIMIT": 2, |
| "NO_MORE_RESULTS": 3, |
| } |
| |
| func (x QueryResultBatch_MoreResultsType) Enum() *QueryResultBatch_MoreResultsType { |
| p := new(QueryResultBatch_MoreResultsType) |
| *p = x |
| return p |
| } |
| func (x QueryResultBatch_MoreResultsType) String() string { |
| return proto.EnumName(QueryResultBatch_MoreResultsType_name, int32(x)) |
| } |
| func (x *QueryResultBatch_MoreResultsType) UnmarshalJSON(data []byte) error { |
| value, err := proto.UnmarshalJSONEnum(QueryResultBatch_MoreResultsType_value, data, "QueryResultBatch_MoreResultsType") |
| if err != nil { |
| return err |
| } |
| *x = QueryResultBatch_MoreResultsType(value) |
| return nil |
| } |
| |
| type ReadOptions_ReadConsistency int32 |
| |
| const ( |
| ReadOptions_DEFAULT ReadOptions_ReadConsistency = 0 |
| ReadOptions_STRONG ReadOptions_ReadConsistency = 1 |
| ReadOptions_EVENTUAL ReadOptions_ReadConsistency = 2 |
| ) |
| |
| var ReadOptions_ReadConsistency_name = map[int32]string{ |
| 0: "DEFAULT", |
| 1: "STRONG", |
| 2: "EVENTUAL", |
| } |
| var ReadOptions_ReadConsistency_value = map[string]int32{ |
| "DEFAULT": 0, |
| "STRONG": 1, |
| "EVENTUAL": 2, |
| } |
| |
| func (x ReadOptions_ReadConsistency) Enum() *ReadOptions_ReadConsistency { |
| p := new(ReadOptions_ReadConsistency) |
| *p = x |
| return p |
| } |
| func (x ReadOptions_ReadConsistency) String() string { |
| return proto.EnumName(ReadOptions_ReadConsistency_name, int32(x)) |
| } |
| func (x *ReadOptions_ReadConsistency) UnmarshalJSON(data []byte) error { |
| value, err := proto.UnmarshalJSONEnum(ReadOptions_ReadConsistency_value, data, "ReadOptions_ReadConsistency") |
| if err != nil { |
| return err |
| } |
| *x = ReadOptions_ReadConsistency(value) |
| return nil |
| } |
| |
| type BeginTransactionRequest_IsolationLevel int32 |
| |
| const ( |
| BeginTransactionRequest_SNAPSHOT BeginTransactionRequest_IsolationLevel = 0 |
| // conflict if their mutations conflict. For example: |
| // Read(A),Write(B) may not conflict with Read(B),Write(A), |
| // but Read(B),Write(B) does conflict with Read(B),Write(B). |
| BeginTransactionRequest_SERIALIZABLE BeginTransactionRequest_IsolationLevel = 1 |
| ) |
| |
| var BeginTransactionRequest_IsolationLevel_name = map[int32]string{ |
| 0: "SNAPSHOT", |
| 1: "SERIALIZABLE", |
| } |
| var BeginTransactionRequest_IsolationLevel_value = map[string]int32{ |
| "SNAPSHOT": 0, |
| "SERIALIZABLE": 1, |
| } |
| |
| func (x BeginTransactionRequest_IsolationLevel) Enum() *BeginTransactionRequest_IsolationLevel { |
| p := new(BeginTransactionRequest_IsolationLevel) |
| *p = x |
| return p |
| } |
| func (x BeginTransactionRequest_IsolationLevel) String() string { |
| return proto.EnumName(BeginTransactionRequest_IsolationLevel_name, int32(x)) |
| } |
| func (x *BeginTransactionRequest_IsolationLevel) UnmarshalJSON(data []byte) error { |
| value, err := proto.UnmarshalJSONEnum(BeginTransactionRequest_IsolationLevel_value, data, "BeginTransactionRequest_IsolationLevel") |
| if err != nil { |
| return err |
| } |
| *x = BeginTransactionRequest_IsolationLevel(value) |
| return nil |
| } |
| |
| type CommitRequest_Mode int32 |
| |
| const ( |
| CommitRequest_TRANSACTIONAL CommitRequest_Mode = 1 |
| CommitRequest_NON_TRANSACTIONAL CommitRequest_Mode = 2 |
| ) |
| |
| var CommitRequest_Mode_name = map[int32]string{ |
| 1: "TRANSACTIONAL", |
| 2: "NON_TRANSACTIONAL", |
| } |
| var CommitRequest_Mode_value = map[string]int32{ |
| "TRANSACTIONAL": 1, |
| "NON_TRANSACTIONAL": 2, |
| } |
| |
| func (x CommitRequest_Mode) Enum() *CommitRequest_Mode { |
| p := new(CommitRequest_Mode) |
| *p = x |
| return p |
| } |
| func (x CommitRequest_Mode) String() string { |
| return proto.EnumName(CommitRequest_Mode_name, int32(x)) |
| } |
| func (x *CommitRequest_Mode) UnmarshalJSON(data []byte) error { |
| value, err := proto.UnmarshalJSONEnum(CommitRequest_Mode_value, data, "CommitRequest_Mode") |
| if err != nil { |
| return err |
| } |
| *x = CommitRequest_Mode(value) |
| return nil |
| } |
| |
| // An identifier for a particular subset of entities. |
| // |
| // Entities are partitioned into various subsets, each used by different |
| // datasets and different namespaces within a dataset and so forth. |
| // |
| // All input partition IDs are normalized before use. |
| // A partition ID is normalized as follows: |
| // If the partition ID is unset or is set to an empty partition ID, replace it |
| // with the context partition ID. |
| // Otherwise, if the partition ID has no dataset ID, assign it the context |
| // partition ID's dataset ID. |
| // Unless otherwise documented, the context partition ID has the dataset ID set |
| // to the context dataset ID and no other partition dimension set. |
| // |
| // A partition ID is empty if all of its fields are unset. |
| // |
| // Partition dimension: |
| // A dimension may be unset. |
| // A dimension's value must never be "". |
| // A dimension's value must match [A-Za-z\d\.\-_]{1,100} |
| // If the value of any dimension matches regex "__.*__", |
| // the partition is reserved/read-only. |
| // A reserved/read-only partition ID is forbidden in certain documented contexts. |
| // |
| // Dataset ID: |
| // A dataset id's value must never be "". |
| // A dataset id's value must match |
| // ([a-z\d\-]{1,100}~)?([a-z\d][a-z\d\-\.]{0,99}:)?([a-z\d][a-z\d\-]{0,99} |
| type PartitionId struct { |
| // The dataset ID. |
| DatasetId *string `protobuf:"bytes,3,opt,name=dataset_id" json:"dataset_id,omitempty"` |
| // The namespace. |
| Namespace *string `protobuf:"bytes,4,opt,name=namespace" json:"namespace,omitempty"` |
| XXX_unrecognized []byte `json:"-"` |
| } |
| |
| func (m *PartitionId) Reset() { *m = PartitionId{} } |
| func (m *PartitionId) String() string { return proto.CompactTextString(m) } |
| func (*PartitionId) ProtoMessage() {} |
| |
| func (m *PartitionId) GetDatasetId() string { |
| if m != nil && m.DatasetId != nil { |
| return *m.DatasetId |
| } |
| return "" |
| } |
| |
| func (m *PartitionId) GetNamespace() string { |
| if m != nil && m.Namespace != nil { |
| return *m.Namespace |
| } |
| return "" |
| } |
| |
| // A unique identifier for an entity. |
| // If a key's partition id or any of its path kinds or names are |
| // reserved/read-only, the key is reserved/read-only. |
| // A reserved/read-only key is forbidden in certain documented contexts. |
| type Key struct { |
| // Entities are partitioned into subsets, currently identified by a dataset |
| // (usually implicitly specified by the project) and namespace ID. |
| // Queries are scoped to a single partition. |
| PartitionId *PartitionId `protobuf:"bytes,1,opt,name=partition_id" json:"partition_id,omitempty"` |
| // The entity path. |
| // An entity path consists of one or more elements composed of a kind and a |
| // string or numerical identifier, which identify entities. The first |
| // element identifies a <em>root entity</em>, the second element identifies |
| // a <em>child</em> of the root entity, the third element a child of the |
| // second entity, and so forth. The entities identified by all prefixes of |
| // the path are called the element's <em>ancestors</em>. |
| // An entity path is always fully complete: ALL of the entity's ancestors |
| // are required to be in the path along with the entity identifier itself. |
| // The only exception is that in some documented cases, the identifier in the |
| // last path element (for the entity) itself may be omitted. A path can never |
| // be empty. |
| PathElement []*Key_PathElement `protobuf:"bytes,2,rep,name=path_element" json:"path_element,omitempty"` |
| XXX_unrecognized []byte `json:"-"` |
| } |
| |
| func (m *Key) Reset() { *m = Key{} } |
| func (m *Key) String() string { return proto.CompactTextString(m) } |
| func (*Key) ProtoMessage() {} |
| |
| func (m *Key) GetPartitionId() *PartitionId { |
| if m != nil { |
| return m.PartitionId |
| } |
| return nil |
| } |
| |
| func (m *Key) GetPathElement() []*Key_PathElement { |
| if m != nil { |
| return m.PathElement |
| } |
| return nil |
| } |
| |
| // A (kind, ID/name) pair used to construct a key path. |
| // |
| // At most one of name or ID may be set. |
| // If either is set, the element is complete. |
| // If neither is set, the element is incomplete. |
| type Key_PathElement struct { |
| // The kind of the entity. |
| // A kind matching regex "__.*__" is reserved/read-only. |
| // A kind must not contain more than 500 characters. |
| // Cannot be "". |
| Kind *string `protobuf:"bytes,1,req,name=kind" json:"kind,omitempty"` |
| // The ID of the entity. |
| // Never equal to zero. Values less than zero are discouraged and will not |
| // be supported in the future. |
| Id *int64 `protobuf:"varint,2,opt,name=id" json:"id,omitempty"` |
| // The name of the entity. |
| // A name matching regex "__.*__" is reserved/read-only. |
| // A name must not be more than 500 characters. |
| // Cannot be "". |
| Name *string `protobuf:"bytes,3,opt,name=name" json:"name,omitempty"` |
| XXX_unrecognized []byte `json:"-"` |
| } |
| |
| func (m *Key_PathElement) Reset() { *m = Key_PathElement{} } |
| func (m *Key_PathElement) String() string { return proto.CompactTextString(m) } |
| func (*Key_PathElement) ProtoMessage() {} |
| |
| func (m *Key_PathElement) GetKind() string { |
| if m != nil && m.Kind != nil { |
| return *m.Kind |
| } |
| return "" |
| } |
| |
| func (m *Key_PathElement) GetId() int64 { |
| if m != nil && m.Id != nil { |
| return *m.Id |
| } |
| return 0 |
| } |
| |
| func (m *Key_PathElement) GetName() string { |
| if m != nil && m.Name != nil { |
| return *m.Name |
| } |
| return "" |
| } |
| |
| // A message that can hold any of the supported value types and associated |
| // metadata. |
| // |
| // At most one of the <type>Value fields may be set. |
| // If none are set the value is "null". |
| // |
| type Value struct { |
| // A boolean value. |
| BooleanValue *bool `protobuf:"varint,1,opt,name=boolean_value" json:"boolean_value,omitempty"` |
| // An integer value. |
| IntegerValue *int64 `protobuf:"varint,2,opt,name=integer_value" json:"integer_value,omitempty"` |
| // A double value. |
| DoubleValue *float64 `protobuf:"fixed64,3,opt,name=double_value" json:"double_value,omitempty"` |
| // A timestamp value. |
| TimestampMicrosecondsValue *int64 `protobuf:"varint,4,opt,name=timestamp_microseconds_value" json:"timestamp_microseconds_value,omitempty"` |
| // A key value. |
| KeyValue *Key `protobuf:"bytes,5,opt,name=key_value" json:"key_value,omitempty"` |
| // A blob key value. |
| BlobKeyValue *string `protobuf:"bytes,16,opt,name=blob_key_value" json:"blob_key_value,omitempty"` |
| // A UTF-8 encoded string value. |
| StringValue *string `protobuf:"bytes,17,opt,name=string_value" json:"string_value,omitempty"` |
| // A blob value. |
| BlobValue []byte `protobuf:"bytes,18,opt,name=blob_value" json:"blob_value,omitempty"` |
| // An entity value. |
| // May have no key. |
| // May have a key with an incomplete key path. |
| // May have a reserved/read-only key. |
| EntityValue *Entity `protobuf:"bytes,6,opt,name=entity_value" json:"entity_value,omitempty"` |
| // A list value. |
| // Cannot contain another list value. |
| // Cannot also have a meaning and indexing set. |
| ListValue []*Value `protobuf:"bytes,7,rep,name=list_value" json:"list_value,omitempty"` |
| // The <code>meaning</code> field is reserved and should not be used. |
| Meaning *int32 `protobuf:"varint,14,opt,name=meaning" json:"meaning,omitempty"` |
| // If the value should be indexed. |
| // |
| // The <code>indexed</code> property may be set for a |
| // <code>null</code> value. |
| // When <code>indexed</code> is <code>true</code>, <code>stringValue</code> |
| // is limited to 500 characters and the blob value is limited to 500 bytes. |
| // Exception: If meaning is set to 2, string_value is limited to 2038 |
| // characters regardless of indexed. |
| // When indexed is true, meaning 15 and 22 are not allowed, and meaning 16 |
| // will be ignored on input (and will never be set on output). |
| // Input values by default have <code>indexed</code> set to |
| // <code>true</code>; however, you can explicitly set <code>indexed</code> to |
| // <code>true</code> if you want. (An output value never has |
| // <code>indexed</code> explicitly set to <code>true</code>.) If a value is |
| // itself an entity, it cannot have <code>indexed</code> set to |
| // <code>true</code>. |
| // Exception: An entity value with meaning 9, 20 or 21 may be indexed. |
| Indexed *bool `protobuf:"varint,15,opt,name=indexed,def=1" json:"indexed,omitempty"` |
| XXX_unrecognized []byte `json:"-"` |
| } |
| |
| func (m *Value) Reset() { *m = Value{} } |
| func (m *Value) String() string { return proto.CompactTextString(m) } |
| func (*Value) ProtoMessage() {} |
| |
| const Default_Value_Indexed bool = true |
| |
| func (m *Value) GetBooleanValue() bool { |
| if m != nil && m.BooleanValue != nil { |
| return *m.BooleanValue |
| } |
| return false |
| } |
| |
| func (m *Value) GetIntegerValue() int64 { |
| if m != nil && m.IntegerValue != nil { |
| return *m.IntegerValue |
| } |
| return 0 |
| } |
| |
| func (m *Value) GetDoubleValue() float64 { |
| if m != nil && m.DoubleValue != nil { |
| return *m.DoubleValue |
| } |
| return 0 |
| } |
| |
| func (m *Value) GetTimestampMicrosecondsValue() int64 { |
| if m != nil && m.TimestampMicrosecondsValue != nil { |
| return *m.TimestampMicrosecondsValue |
| } |
| return 0 |
| } |
| |
| func (m *Value) GetKeyValue() *Key { |
| if m != nil { |
| return m.KeyValue |
| } |
| return nil |
| } |
| |
| func (m *Value) GetBlobKeyValue() string { |
| if m != nil && m.BlobKeyValue != nil { |
| return *m.BlobKeyValue |
| } |
| return "" |
| } |
| |
| func (m *Value) GetStringValue() string { |
| if m != nil && m.StringValue != nil { |
| return *m.StringValue |
| } |
| return "" |
| } |
| |
| func (m *Value) GetBlobValue() []byte { |
| if m != nil { |
| return m.BlobValue |
| } |
| return nil |
| } |
| |
| func (m *Value) GetEntityValue() *Entity { |
| if m != nil { |
| return m.EntityValue |
| } |
| return nil |
| } |
| |
| func (m *Value) GetListValue() []*Value { |
| if m != nil { |
| return m.ListValue |
| } |
| return nil |
| } |
| |
| func (m *Value) GetMeaning() int32 { |
| if m != nil && m.Meaning != nil { |
| return *m.Meaning |
| } |
| return 0 |
| } |
| |
| func (m *Value) GetIndexed() bool { |
| if m != nil && m.Indexed != nil { |
| return *m.Indexed |
| } |
| return Default_Value_Indexed |
| } |
| |
| // An entity property. |
| type Property struct { |
| // The name of the property. |
| // A property name matching regex "__.*__" is reserved. |
| // A reserved property name is forbidden in certain documented contexts. |
| // The name must not contain more than 500 characters. |
| // Cannot be "". |
| Name *string `protobuf:"bytes,1,req,name=name" json:"name,omitempty"` |
| // The value(s) of the property. |
| // Each value can have only one value property populated. For example, |
| // you cannot have a values list of <code>{ value: { integerValue: 22, |
| // stringValue: "a" } }</code>, but you can have <code>{ value: { listValue: |
| // [ { integerValue: 22 }, { stringValue: "a" } ] }</code>. |
| Value *Value `protobuf:"bytes,4,req,name=value" json:"value,omitempty"` |
| XXX_unrecognized []byte `json:"-"` |
| } |
| |
| func (m *Property) Reset() { *m = Property{} } |
| func (m *Property) String() string { return proto.CompactTextString(m) } |
| func (*Property) ProtoMessage() {} |
| |
| func (m *Property) GetName() string { |
| if m != nil && m.Name != nil { |
| return *m.Name |
| } |
| return "" |
| } |
| |
| func (m *Property) GetValue() *Value { |
| if m != nil { |
| return m.Value |
| } |
| return nil |
| } |
| |
| // An entity. |
| // |
| // An entity is limited to 1 megabyte when stored. That <em>roughly</em> |
| // corresponds to a limit of 1 megabyte for the serialized form of this |
| // message. |
| type Entity struct { |
| // The entity's key. |
| // |
| // An entity must have a key, unless otherwise documented (for example, |
| // an entity in <code>Value.entityValue</code> may have no key). |
| // An entity's kind is its key's path's last element's kind, |
| // or null if it has no key. |
| Key *Key `protobuf:"bytes,1,opt,name=key" json:"key,omitempty"` |
| // The entity's properties. |
| // Each property's name must be unique for its entity. |
| Property []*Property `protobuf:"bytes,2,rep,name=property" json:"property,omitempty"` |
| XXX_unrecognized []byte `json:"-"` |
| } |
| |
| func (m *Entity) Reset() { *m = Entity{} } |
| func (m *Entity) String() string { return proto.CompactTextString(m) } |
| func (*Entity) ProtoMessage() {} |
| |
| func (m *Entity) GetKey() *Key { |
| if m != nil { |
| return m.Key |
| } |
| return nil |
| } |
| |
| func (m *Entity) GetProperty() []*Property { |
| if m != nil { |
| return m.Property |
| } |
| return nil |
| } |
| |
| // The result of fetching an entity from the datastore. |
| type EntityResult struct { |
| // The resulting entity. |
| Entity *Entity `protobuf:"bytes,1,req,name=entity" json:"entity,omitempty"` |
| XXX_unrecognized []byte `json:"-"` |
| } |
| |
| func (m *EntityResult) Reset() { *m = EntityResult{} } |
| func (m *EntityResult) String() string { return proto.CompactTextString(m) } |
| func (*EntityResult) ProtoMessage() {} |
| |
| func (m *EntityResult) GetEntity() *Entity { |
| if m != nil { |
| return m.Entity |
| } |
| return nil |
| } |
| |
| // A query. |
| type Query struct { |
| // The projection to return. If not set the entire entity is returned. |
| Projection []*PropertyExpression `protobuf:"bytes,2,rep,name=projection" json:"projection,omitempty"` |
| // The kinds to query (if empty, returns entities from all kinds). |
| Kind []*KindExpression `protobuf:"bytes,3,rep,name=kind" json:"kind,omitempty"` |
| // The filter to apply (optional). |
| Filter *Filter `protobuf:"bytes,4,opt,name=filter" json:"filter,omitempty"` |
| // The order to apply to the query results (if empty, order is unspecified). |
| Order []*PropertyOrder `protobuf:"bytes,5,rep,name=order" json:"order,omitempty"` |
| // The properties to group by (if empty, no grouping is applied to the |
| // result set). |
| GroupBy []*PropertyReference `protobuf:"bytes,6,rep,name=group_by" json:"group_by,omitempty"` |
| // A starting point for the query results. Optional. Query cursors are |
| // returned in query result batches. |
| StartCursor []byte `protobuf:"bytes,7,opt,name=start_cursor" json:"start_cursor,omitempty"` |
| // An ending point for the query results. Optional. Query cursors are |
| // returned in query result batches. |
| EndCursor []byte `protobuf:"bytes,8,opt,name=end_cursor" json:"end_cursor,omitempty"` |
| // The number of results to skip. Applies before limit, but after all other |
| // constraints (optional, defaults to 0). |
| Offset *int32 `protobuf:"varint,10,opt,name=offset,def=0" json:"offset,omitempty"` |
| // The maximum number of results to return. Applies after all other |
| // constraints. Optional. |
| Limit *int32 `protobuf:"varint,11,opt,name=limit" json:"limit,omitempty"` |
| XXX_unrecognized []byte `json:"-"` |
| } |
| |
| func (m *Query) Reset() { *m = Query{} } |
| func (m *Query) String() string { return proto.CompactTextString(m) } |
| func (*Query) ProtoMessage() {} |
| |
| const Default_Query_Offset int32 = 0 |
| |
| func (m *Query) GetProjection() []*PropertyExpression { |
| if m != nil { |
| return m.Projection |
| } |
| return nil |
| } |
| |
| func (m *Query) GetKind() []*KindExpression { |
| if m != nil { |
| return m.Kind |
| } |
| return nil |
| } |
| |
| func (m *Query) GetFilter() *Filter { |
| if m != nil { |
| return m.Filter |
| } |
| return nil |
| } |
| |
| func (m *Query) GetOrder() []*PropertyOrder { |
| if m != nil { |
| return m.Order |
| } |
| return nil |
| } |
| |
| func (m *Query) GetGroupBy() []*PropertyReference { |
| if m != nil { |
| return m.GroupBy |
| } |
| return nil |
| } |
| |
| func (m *Query) GetStartCursor() []byte { |
| if m != nil { |
| return m.StartCursor |
| } |
| return nil |
| } |
| |
| func (m *Query) GetEndCursor() []byte { |
| if m != nil { |
| return m.EndCursor |
| } |
| return nil |
| } |
| |
| func (m *Query) GetOffset() int32 { |
| if m != nil && m.Offset != nil { |
| return *m.Offset |
| } |
| return Default_Query_Offset |
| } |
| |
| func (m *Query) GetLimit() int32 { |
| if m != nil && m.Limit != nil { |
| return *m.Limit |
| } |
| return 0 |
| } |
| |
| // A representation of a kind. |
| type KindExpression struct { |
| // The name of the kind. |
| Name *string `protobuf:"bytes,1,req,name=name" json:"name,omitempty"` |
| XXX_unrecognized []byte `json:"-"` |
| } |
| |
| func (m *KindExpression) Reset() { *m = KindExpression{} } |
| func (m *KindExpression) String() string { return proto.CompactTextString(m) } |
| func (*KindExpression) ProtoMessage() {} |
| |
| func (m *KindExpression) GetName() string { |
| if m != nil && m.Name != nil { |
| return *m.Name |
| } |
| return "" |
| } |
| |
| // A reference to a property relative to the kind expressions. |
| // exactly. |
| type PropertyReference struct { |
| // The name of the property. |
| Name *string `protobuf:"bytes,2,req,name=name" json:"name,omitempty"` |
| XXX_unrecognized []byte `json:"-"` |
| } |
| |
| func (m *PropertyReference) Reset() { *m = PropertyReference{} } |
| func (m *PropertyReference) String() string { return proto.CompactTextString(m) } |
| func (*PropertyReference) ProtoMessage() {} |
| |
| func (m *PropertyReference) GetName() string { |
| if m != nil && m.Name != nil { |
| return *m.Name |
| } |
| return "" |
| } |
| |
| // A representation of a property in a projection. |
| type PropertyExpression struct { |
| // The property to project. |
| Property *PropertyReference `protobuf:"bytes,1,req,name=property" json:"property,omitempty"` |
| // The aggregation function to apply to the property. Optional. |
| // Can only be used when grouping by at least one property. Must |
| // then be set on all properties in the projection that are not |
| // being grouped by. |
| AggregationFunction *PropertyExpression_AggregationFunction `protobuf:"varint,2,opt,name=aggregation_function,enum=datastore.PropertyExpression_AggregationFunction" json:"aggregation_function,omitempty"` |
| XXX_unrecognized []byte `json:"-"` |
| } |
| |
| func (m *PropertyExpression) Reset() { *m = PropertyExpression{} } |
| func (m *PropertyExpression) String() string { return proto.CompactTextString(m) } |
| func (*PropertyExpression) ProtoMessage() {} |
| |
| func (m *PropertyExpression) GetProperty() *PropertyReference { |
| if m != nil { |
| return m.Property |
| } |
| return nil |
| } |
| |
| func (m *PropertyExpression) GetAggregationFunction() PropertyExpression_AggregationFunction { |
| if m != nil && m.AggregationFunction != nil { |
| return *m.AggregationFunction |
| } |
| return PropertyExpression_FIRST |
| } |
| |
| // The desired order for a specific property. |
| type PropertyOrder struct { |
| // The property to order by. |
| Property *PropertyReference `protobuf:"bytes,1,req,name=property" json:"property,omitempty"` |
| // The direction to order by. |
| Direction *PropertyOrder_Direction `protobuf:"varint,2,opt,name=direction,enum=datastore.PropertyOrder_Direction,def=1" json:"direction,omitempty"` |
| XXX_unrecognized []byte `json:"-"` |
| } |
| |
| func (m *PropertyOrder) Reset() { *m = PropertyOrder{} } |
| func (m *PropertyOrder) String() string { return proto.CompactTextString(m) } |
| func (*PropertyOrder) ProtoMessage() {} |
| |
| const Default_PropertyOrder_Direction PropertyOrder_Direction = PropertyOrder_ASCENDING |
| |
| func (m *PropertyOrder) GetProperty() *PropertyReference { |
| if m != nil { |
| return m.Property |
| } |
| return nil |
| } |
| |
| func (m *PropertyOrder) GetDirection() PropertyOrder_Direction { |
| if m != nil && m.Direction != nil { |
| return *m.Direction |
| } |
| return Default_PropertyOrder_Direction |
| } |
| |
| // A holder for any type of filter. Exactly one field should be specified. |
| type Filter struct { |
| // A composite filter. |
| CompositeFilter *CompositeFilter `protobuf:"bytes,1,opt,name=composite_filter" json:"composite_filter,omitempty"` |
| // A filter on a property. |
| PropertyFilter *PropertyFilter `protobuf:"bytes,2,opt,name=property_filter" json:"property_filter,omitempty"` |
| XXX_unrecognized []byte `json:"-"` |
| } |
| |
| func (m *Filter) Reset() { *m = Filter{} } |
| func (m *Filter) String() string { return proto.CompactTextString(m) } |
| func (*Filter) ProtoMessage() {} |
| |
| func (m *Filter) GetCompositeFilter() *CompositeFilter { |
| if m != nil { |
| return m.CompositeFilter |
| } |
| return nil |
| } |
| |
| func (m *Filter) GetPropertyFilter() *PropertyFilter { |
| if m != nil { |
| return m.PropertyFilter |
| } |
| return nil |
| } |
| |
| // A filter that merges the multiple other filters using the given operation. |
| type CompositeFilter struct { |
| // The operator for combining multiple filters. |
| Operator *CompositeFilter_Operator `protobuf:"varint,1,req,name=operator,enum=datastore.CompositeFilter_Operator" json:"operator,omitempty"` |
| // The list of filters to combine. |
| // Must contain at least one filter. |
| Filter []*Filter `protobuf:"bytes,2,rep,name=filter" json:"filter,omitempty"` |
| XXX_unrecognized []byte `json:"-"` |
| } |
| |
| func (m *CompositeFilter) Reset() { *m = CompositeFilter{} } |
| func (m *CompositeFilter) String() string { return proto.CompactTextString(m) } |
| func (*CompositeFilter) ProtoMessage() {} |
| |
| func (m *CompositeFilter) GetOperator() CompositeFilter_Operator { |
| if m != nil && m.Operator != nil { |
| return *m.Operator |
| } |
| return CompositeFilter_AND |
| } |
| |
| func (m *CompositeFilter) GetFilter() []*Filter { |
| if m != nil { |
| return m.Filter |
| } |
| return nil |
| } |
| |
| // A filter on a specific property. |
| type PropertyFilter struct { |
| // The property to filter by. |
| Property *PropertyReference `protobuf:"bytes,1,req,name=property" json:"property,omitempty"` |
| // The operator to filter by. |
| Operator *PropertyFilter_Operator `protobuf:"varint,2,req,name=operator,enum=datastore.PropertyFilter_Operator" json:"operator,omitempty"` |
| // The value to compare the property to. |
| Value *Value `protobuf:"bytes,3,req,name=value" json:"value,omitempty"` |
| XXX_unrecognized []byte `json:"-"` |
| } |
| |
| func (m *PropertyFilter) Reset() { *m = PropertyFilter{} } |
| func (m *PropertyFilter) String() string { return proto.CompactTextString(m) } |
| func (*PropertyFilter) ProtoMessage() {} |
| |
| func (m *PropertyFilter) GetProperty() *PropertyReference { |
| if m != nil { |
| return m.Property |
| } |
| return nil |
| } |
| |
| func (m *PropertyFilter) GetOperator() PropertyFilter_Operator { |
| if m != nil && m.Operator != nil { |
| return *m.Operator |
| } |
| return PropertyFilter_LESS_THAN |
| } |
| |
| func (m *PropertyFilter) GetValue() *Value { |
| if m != nil { |
| return m.Value |
| } |
| return nil |
| } |
| |
| // A GQL query. |
| type GqlQuery struct { |
| QueryString *string `protobuf:"bytes,1,req,name=query_string" json:"query_string,omitempty"` |
| // When false, the query string must not contain a literal. |
| AllowLiteral *bool `protobuf:"varint,2,opt,name=allow_literal,def=0" json:"allow_literal,omitempty"` |
| // A named argument must set field GqlQueryArg.name. |
| // No two named arguments may have the same name. |
| // For each non-reserved named binding site in the query string, |
| // there must be a named argument with that name, |
| // but not necessarily the inverse. |
| NameArg []*GqlQueryArg `protobuf:"bytes,3,rep,name=name_arg" json:"name_arg,omitempty"` |
| // Numbered binding site @1 references the first numbered argument, |
| // effectively using 1-based indexing, rather than the usual 0. |
| // A numbered argument must NOT set field GqlQueryArg.name. |
| // For each binding site numbered i in query_string, |
| // there must be an ith numbered argument. |
| // The inverse must also be true. |
| NumberArg []*GqlQueryArg `protobuf:"bytes,4,rep,name=number_arg" json:"number_arg,omitempty"` |
| XXX_unrecognized []byte `json:"-"` |
| } |
| |
| func (m *GqlQuery) Reset() { *m = GqlQuery{} } |
| func (m *GqlQuery) String() string { return proto.CompactTextString(m) } |
| func (*GqlQuery) ProtoMessage() {} |
| |
| const Default_GqlQuery_AllowLiteral bool = false |
| |
| func (m *GqlQuery) GetQueryString() string { |
| if m != nil && m.QueryString != nil { |
| return *m.QueryString |
| } |
| return "" |
| } |
| |
| func (m *GqlQuery) GetAllowLiteral() bool { |
| if m != nil && m.AllowLiteral != nil { |
| return *m.AllowLiteral |
| } |
| return Default_GqlQuery_AllowLiteral |
| } |
| |
| func (m *GqlQuery) GetNameArg() []*GqlQueryArg { |
| if m != nil { |
| return m.NameArg |
| } |
| return nil |
| } |
| |
| func (m *GqlQuery) GetNumberArg() []*GqlQueryArg { |
| if m != nil { |
| return m.NumberArg |
| } |
| return nil |
| } |
| |
| // A binding argument for a GQL query. |
| // Exactly one of fields value and cursor must be set. |
| type GqlQueryArg struct { |
| // Must match regex "[A-Za-z_$][A-Za-z_$0-9]*". |
| // Must not match regex "__.*__". |
| // Must not be "". |
| Name *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"` |
| Value *Value `protobuf:"bytes,2,opt,name=value" json:"value,omitempty"` |
| Cursor []byte `protobuf:"bytes,3,opt,name=cursor" json:"cursor,omitempty"` |
| XXX_unrecognized []byte `json:"-"` |
| } |
| |
| func (m *GqlQueryArg) Reset() { *m = GqlQueryArg{} } |
| func (m *GqlQueryArg) String() string { return proto.CompactTextString(m) } |
| func (*GqlQueryArg) ProtoMessage() {} |
| |
| func (m *GqlQueryArg) GetName() string { |
| if m != nil && m.Name != nil { |
| return *m.Name |
| } |
| return "" |
| } |
| |
| func (m *GqlQueryArg) GetValue() *Value { |
| if m != nil { |
| return m.Value |
| } |
| return nil |
| } |
| |
| func (m *GqlQueryArg) GetCursor() []byte { |
| if m != nil { |
| return m.Cursor |
| } |
| return nil |
| } |
| |
| // A batch of results produced by a query. |
| type QueryResultBatch struct { |
| // The result type for every entity in entityResults. |
| EntityResultType *EntityResult_ResultType `protobuf:"varint,1,req,name=entity_result_type,enum=datastore.EntityResult_ResultType" json:"entity_result_type,omitempty"` |
| // The results for this batch. |
| EntityResult []*EntityResult `protobuf:"bytes,2,rep,name=entity_result" json:"entity_result,omitempty"` |
| // A cursor that points to the position after the last result in the batch. |
| // May be absent. |
| EndCursor []byte `protobuf:"bytes,4,opt,name=end_cursor" json:"end_cursor,omitempty"` |
| // The state of the query after the current batch. |
| MoreResults *QueryResultBatch_MoreResultsType `protobuf:"varint,5,req,name=more_results,enum=datastore.QueryResultBatch_MoreResultsType" json:"more_results,omitempty"` |
| // The number of results skipped because of <code>Query.offset</code>. |
| SkippedResults *int32 `protobuf:"varint,6,opt,name=skipped_results" json:"skipped_results,omitempty"` |
| XXX_unrecognized []byte `json:"-"` |
| } |
| |
| func (m *QueryResultBatch) Reset() { *m = QueryResultBatch{} } |
| func (m *QueryResultBatch) String() string { return proto.CompactTextString(m) } |
| func (*QueryResultBatch) ProtoMessage() {} |
| |
| func (m *QueryResultBatch) GetEntityResultType() EntityResult_ResultType { |
| if m != nil && m.EntityResultType != nil { |
| return *m.EntityResultType |
| } |
| return EntityResult_FULL |
| } |
| |
| func (m *QueryResultBatch) GetEntityResult() []*EntityResult { |
| if m != nil { |
| return m.EntityResult |
| } |
| return nil |
| } |
| |
| func (m *QueryResultBatch) GetEndCursor() []byte { |
| if m != nil { |
| return m.EndCursor |
| } |
| return nil |
| } |
| |
| func (m *QueryResultBatch) GetMoreResults() QueryResultBatch_MoreResultsType { |
| if m != nil && m.MoreResults != nil { |
| return *m.MoreResults |
| } |
| return QueryResultBatch_NOT_FINISHED |
| } |
| |
| func (m *QueryResultBatch) GetSkippedResults() int32 { |
| if m != nil && m.SkippedResults != nil { |
| return *m.SkippedResults |
| } |
| return 0 |
| } |
| |
| // A set of changes to apply. |
| // |
| // No entity in this message may have a reserved property name, |
| // not even a property in an entity in a value. |
| // No value in this message may have meaning 18, |
| // not even a value in an entity in another value. |
| // |
| // If entities with duplicate keys are present, an arbitrary choice will |
| // be made as to which is written. |
| type Mutation struct { |
| // Entities to upsert. |
| // Each upserted entity's key must have a complete path and |
| // must not be reserved/read-only. |
| Upsert []*Entity `protobuf:"bytes,1,rep,name=upsert" json:"upsert,omitempty"` |
| // Entities to update. |
| // Each updated entity's key must have a complete path and |
| // must not be reserved/read-only. |
| Update []*Entity `protobuf:"bytes,2,rep,name=update" json:"update,omitempty"` |
| // Entities to insert. |
| // Each inserted entity's key must have a complete path and |
| // must not be reserved/read-only. |
| Insert []*Entity `protobuf:"bytes,3,rep,name=insert" json:"insert,omitempty"` |
| // Insert entities with a newly allocated ID. |
| // Each inserted entity's key must omit the final identifier in its path and |
| // must not be reserved/read-only. |
| InsertAutoId []*Entity `protobuf:"bytes,4,rep,name=insert_auto_id" json:"insert_auto_id,omitempty"` |
| // Keys of entities to delete. |
| // Each key must have a complete key path and must not be reserved/read-only. |
| Delete []*Key `protobuf:"bytes,5,rep,name=delete" json:"delete,omitempty"` |
| // Ignore a user specified read-only period. Optional. |
| Force *bool `protobuf:"varint,6,opt,name=force" json:"force,omitempty"` |
| XXX_unrecognized []byte `json:"-"` |
| } |
| |
| func (m *Mutation) Reset() { *m = Mutation{} } |
| func (m *Mutation) String() string { return proto.CompactTextString(m) } |
| func (*Mutation) ProtoMessage() {} |
| |
| func (m *Mutation) GetUpsert() []*Entity { |
| if m != nil { |
| return m.Upsert |
| } |
| return nil |
| } |
| |
| func (m *Mutation) GetUpdate() []*Entity { |
| if m != nil { |
| return m.Update |
| } |
| return nil |
| } |
| |
| func (m *Mutation) GetInsert() []*Entity { |
| if m != nil { |
| return m.Insert |
| } |
| return nil |
| } |
| |
| func (m *Mutation) GetInsertAutoId() []*Entity { |
| if m != nil { |
| return m.InsertAutoId |
| } |
| return nil |
| } |
| |
| func (m *Mutation) GetDelete() []*Key { |
| if m != nil { |
| return m.Delete |
| } |
| return nil |
| } |
| |
| func (m *Mutation) GetForce() bool { |
| if m != nil && m.Force != nil { |
| return *m.Force |
| } |
| return false |
| } |
| |
| // The result of applying a mutation. |
| type MutationResult struct { |
| // Number of index writes. |
| IndexUpdates *int32 `protobuf:"varint,1,req,name=index_updates" json:"index_updates,omitempty"` |
| // Keys for <code>insertAutoId</code> entities. One per entity from the |
| // request, in the same order. |
| InsertAutoIdKey []*Key `protobuf:"bytes,2,rep,name=insert_auto_id_key" json:"insert_auto_id_key,omitempty"` |
| XXX_unrecognized []byte `json:"-"` |
| } |
| |
| func (m *MutationResult) Reset() { *m = MutationResult{} } |
| func (m *MutationResult) String() string { return proto.CompactTextString(m) } |
| func (*MutationResult) ProtoMessage() {} |
| |
| func (m *MutationResult) GetIndexUpdates() int32 { |
| if m != nil && m.IndexUpdates != nil { |
| return *m.IndexUpdates |
| } |
| return 0 |
| } |
| |
| func (m *MutationResult) GetInsertAutoIdKey() []*Key { |
| if m != nil { |
| return m.InsertAutoIdKey |
| } |
| return nil |
| } |
| |
| // Options shared by read requests. |
| type ReadOptions struct { |
| // The read consistency to use. |
| // Cannot be set when transaction is set. |
| // Lookup and ancestor queries default to STRONG, global queries default to |
| // EVENTUAL and cannot be set to STRONG. |
| ReadConsistency *ReadOptions_ReadConsistency `protobuf:"varint,1,opt,name=read_consistency,enum=datastore.ReadOptions_ReadConsistency,def=0" json:"read_consistency,omitempty"` |
| // The transaction to use. Optional. |
| Transaction []byte `protobuf:"bytes,2,opt,name=transaction" json:"transaction,omitempty"` |
| XXX_unrecognized []byte `json:"-"` |
| } |
| |
| func (m *ReadOptions) Reset() { *m = ReadOptions{} } |
| func (m *ReadOptions) String() string { return proto.CompactTextString(m) } |
| func (*ReadOptions) ProtoMessage() {} |
| |
| const Default_ReadOptions_ReadConsistency ReadOptions_ReadConsistency = ReadOptions_DEFAULT |
| |
| func (m *ReadOptions) GetReadConsistency() ReadOptions_ReadConsistency { |
| if m != nil && m.ReadConsistency != nil { |
| return *m.ReadConsistency |
| } |
| return Default_ReadOptions_ReadConsistency |
| } |
| |
| func (m *ReadOptions) GetTransaction() []byte { |
| if m != nil { |
| return m.Transaction |
| } |
| return nil |
| } |
| |
| // The request for Lookup. |
| type LookupRequest struct { |
| // Options for this lookup request. Optional. |
| ReadOptions *ReadOptions `protobuf:"bytes,1,opt,name=read_options" json:"read_options,omitempty"` |
| // Keys of entities to look up from the datastore. |
| Key []*Key `protobuf:"bytes,3,rep,name=key" json:"key,omitempty"` |
| XXX_unrecognized []byte `json:"-"` |
| } |
| |
| func (m *LookupRequest) Reset() { *m = LookupRequest{} } |
| func (m *LookupRequest) String() string { return proto.CompactTextString(m) } |
| func (*LookupRequest) ProtoMessage() {} |
| |
| func (m *LookupRequest) GetReadOptions() *ReadOptions { |
| if m != nil { |
| return m.ReadOptions |
| } |
| return nil |
| } |
| |
| func (m *LookupRequest) GetKey() []*Key { |
| if m != nil { |
| return m.Key |
| } |
| return nil |
| } |
| |
| // The response for Lookup. |
| type LookupResponse struct { |
| // Entities found as ResultType.FULL entities. |
| Found []*EntityResult `protobuf:"bytes,1,rep,name=found" json:"found,omitempty"` |
| // Entities not found as ResultType.KEY_ONLY entities. |
| Missing []*EntityResult `protobuf:"bytes,2,rep,name=missing" json:"missing,omitempty"` |
| // A list of keys that were not looked up due to resource constraints. |
| Deferred []*Key `protobuf:"bytes,3,rep,name=deferred" json:"deferred,omitempty"` |
| XXX_unrecognized []byte `json:"-"` |
| } |
| |
| func (m *LookupResponse) Reset() { *m = LookupResponse{} } |
| func (m *LookupResponse) String() string { return proto.CompactTextString(m) } |
| func (*LookupResponse) ProtoMessage() {} |
| |
| func (m *LookupResponse) GetFound() []*EntityResult { |
| if m != nil { |
| return m.Found |
| } |
| return nil |
| } |
| |
| func (m *LookupResponse) GetMissing() []*EntityResult { |
| if m != nil { |
| return m.Missing |
| } |
| return nil |
| } |
| |
| func (m *LookupResponse) GetDeferred() []*Key { |
| if m != nil { |
| return m.Deferred |
| } |
| return nil |
| } |
| |
| // The request for RunQuery. |
| type RunQueryRequest struct { |
| // The options for this query. |
| ReadOptions *ReadOptions `protobuf:"bytes,1,opt,name=read_options" json:"read_options,omitempty"` |
| // Entities are partitioned into subsets, identified by a dataset (usually |
| // implicitly specified by the project) and namespace ID. Queries are scoped |
| // to a single partition. |
| // This partition ID is normalized with the standard default context |
| // partition ID, but all other partition IDs in RunQueryRequest are |
| // normalized with this partition ID as the context partition ID. |
| PartitionId *PartitionId `protobuf:"bytes,2,opt,name=partition_id" json:"partition_id,omitempty"` |
| // The query to run. |
| // Either this field or field gql_query must be set, but not both. |
| Query *Query `protobuf:"bytes,3,opt,name=query" json:"query,omitempty"` |
| // The GQL query to run. |
| // Either this field or field query must be set, but not both. |
| GqlQuery *GqlQuery `protobuf:"bytes,7,opt,name=gql_query" json:"gql_query,omitempty"` |
| XXX_unrecognized []byte `json:"-"` |
| } |
| |
| func (m *RunQueryRequest) Reset() { *m = RunQueryRequest{} } |
| func (m *RunQueryRequest) String() string { return proto.CompactTextString(m) } |
| func (*RunQueryRequest) ProtoMessage() {} |
| |
| func (m *RunQueryRequest) GetReadOptions() *ReadOptions { |
| if m != nil { |
| return m.ReadOptions |
| } |
| return nil |
| } |
| |
| func (m *RunQueryRequest) GetPartitionId() *PartitionId { |
| if m != nil { |
| return m.PartitionId |
| } |
| return nil |
| } |
| |
| func (m *RunQueryRequest) GetQuery() *Query { |
| if m != nil { |
| return m.Query |
| } |
| return nil |
| } |
| |
| func (m *RunQueryRequest) GetGqlQuery() *GqlQuery { |
| if m != nil { |
| return m.GqlQuery |
| } |
| return nil |
| } |
| |
| // The response for RunQuery. |
| type RunQueryResponse struct { |
| // A batch of query results (always present). |
| Batch *QueryResultBatch `protobuf:"bytes,1,opt,name=batch" json:"batch,omitempty"` |
| XXX_unrecognized []byte `json:"-"` |
| } |
| |
| func (m *RunQueryResponse) Reset() { *m = RunQueryResponse{} } |
| func (m *RunQueryResponse) String() string { return proto.CompactTextString(m) } |
| func (*RunQueryResponse) ProtoMessage() {} |
| |
| func (m *RunQueryResponse) GetBatch() *QueryResultBatch { |
| if m != nil { |
| return m.Batch |
| } |
| return nil |
| } |
| |
| // The request for BeginTransaction. |
| type BeginTransactionRequest struct { |
| // The transaction isolation level. |
| IsolationLevel *BeginTransactionRequest_IsolationLevel `protobuf:"varint,1,opt,name=isolation_level,enum=datastore.BeginTransactionRequest_IsolationLevel,def=0" json:"isolation_level,omitempty"` |
| XXX_unrecognized []byte `json:"-"` |
| } |
| |
| func (m *BeginTransactionRequest) Reset() { *m = BeginTransactionRequest{} } |
| func (m *BeginTransactionRequest) String() string { return proto.CompactTextString(m) } |
| func (*BeginTransactionRequest) ProtoMessage() {} |
| |
| const Default_BeginTransactionRequest_IsolationLevel BeginTransactionRequest_IsolationLevel = BeginTransactionRequest_SNAPSHOT |
| |
| func (m *BeginTransactionRequest) GetIsolationLevel() BeginTransactionRequest_IsolationLevel { |
| if m != nil && m.IsolationLevel != nil { |
| return *m.IsolationLevel |
| } |
| return Default_BeginTransactionRequest_IsolationLevel |
| } |
| |
| // The response for BeginTransaction. |
| type BeginTransactionResponse struct { |
| // The transaction identifier (always present). |
| Transaction []byte `protobuf:"bytes,1,opt,name=transaction" json:"transaction,omitempty"` |
| XXX_unrecognized []byte `json:"-"` |
| } |
| |
| func (m *BeginTransactionResponse) Reset() { *m = BeginTransactionResponse{} } |
| func (m *BeginTransactionResponse) String() string { return proto.CompactTextString(m) } |
| func (*BeginTransactionResponse) ProtoMessage() {} |
| |
| func (m *BeginTransactionResponse) GetTransaction() []byte { |
| if m != nil { |
| return m.Transaction |
| } |
| return nil |
| } |
| |
| // The request for Rollback. |
| type RollbackRequest struct { |
| // The transaction identifier, returned by a call to |
| // <code>beginTransaction</code>. |
| Transaction []byte `protobuf:"bytes,1,req,name=transaction" json:"transaction,omitempty"` |
| XXX_unrecognized []byte `json:"-"` |
| } |
| |
| func (m *RollbackRequest) Reset() { *m = RollbackRequest{} } |
| func (m *RollbackRequest) String() string { return proto.CompactTextString(m) } |
| func (*RollbackRequest) ProtoMessage() {} |
| |
| func (m *RollbackRequest) GetTransaction() []byte { |
| if m != nil { |
| return m.Transaction |
| } |
| return nil |
| } |
| |
| // The response for Rollback. |
| type RollbackResponse struct { |
| XXX_unrecognized []byte `json:"-"` |
| } |
| |
| func (m *RollbackResponse) Reset() { *m = RollbackResponse{} } |
| func (m *RollbackResponse) String() string { return proto.CompactTextString(m) } |
| func (*RollbackResponse) ProtoMessage() {} |
| |
| // The request for Commit. |
| type CommitRequest struct { |
| // The transaction identifier, returned by a call to |
| // <code>beginTransaction</code>. Must be set when mode is TRANSACTIONAL. |
| Transaction []byte `protobuf:"bytes,1,opt,name=transaction" json:"transaction,omitempty"` |
| // The mutation to perform. Optional. |
| Mutation *Mutation `protobuf:"bytes,2,opt,name=mutation" json:"mutation,omitempty"` |
| // The type of commit to perform. Either TRANSACTIONAL or NON_TRANSACTIONAL. |
| Mode *CommitRequest_Mode `protobuf:"varint,5,opt,name=mode,enum=datastore.CommitRequest_Mode,def=1" json:"mode,omitempty"` |
| XXX_unrecognized []byte `json:"-"` |
| } |
| |
| func (m *CommitRequest) Reset() { *m = CommitRequest{} } |
| func (m *CommitRequest) String() string { return proto.CompactTextString(m) } |
| func (*CommitRequest) ProtoMessage() {} |
| |
| const Default_CommitRequest_Mode CommitRequest_Mode = CommitRequest_TRANSACTIONAL |
| |
| func (m *CommitRequest) GetTransaction() []byte { |
| if m != nil { |
| return m.Transaction |
| } |
| return nil |
| } |
| |
| func (m *CommitRequest) GetMutation() *Mutation { |
| if m != nil { |
| return m.Mutation |
| } |
| return nil |
| } |
| |
| func (m *CommitRequest) GetMode() CommitRequest_Mode { |
| if m != nil && m.Mode != nil { |
| return *m.Mode |
| } |
| return Default_CommitRequest_Mode |
| } |
| |
| // The response for Commit. |
| type CommitResponse struct { |
| // The result of performing the mutation (if any). |
| MutationResult *MutationResult `protobuf:"bytes,1,opt,name=mutation_result" json:"mutation_result,omitempty"` |
| XXX_unrecognized []byte `json:"-"` |
| } |
| |
| func (m *CommitResponse) Reset() { *m = CommitResponse{} } |
| func (m *CommitResponse) String() string { return proto.CompactTextString(m) } |
| func (*CommitResponse) ProtoMessage() {} |
| |
| func (m *CommitResponse) GetMutationResult() *MutationResult { |
| if m != nil { |
| return m.MutationResult |
| } |
| return nil |
| } |
| |
| // The request for AllocateIds. |
| type AllocateIdsRequest struct { |
| // A list of keys with incomplete key paths to allocate IDs for. |
| // No key may be reserved/read-only. |
| Key []*Key `protobuf:"bytes,1,rep,name=key" json:"key,omitempty"` |
| XXX_unrecognized []byte `json:"-"` |
| } |
| |
| func (m *AllocateIdsRequest) Reset() { *m = AllocateIdsRequest{} } |
| func (m *AllocateIdsRequest) String() string { return proto.CompactTextString(m) } |
| func (*AllocateIdsRequest) ProtoMessage() {} |
| |
| func (m *AllocateIdsRequest) GetKey() []*Key { |
| if m != nil { |
| return m.Key |
| } |
| return nil |
| } |
| |
| // The response for AllocateIds. |
| type AllocateIdsResponse struct { |
| // The keys specified in the request (in the same order), each with |
| // its key path completed with a newly allocated ID. |
| Key []*Key `protobuf:"bytes,1,rep,name=key" json:"key,omitempty"` |
| XXX_unrecognized []byte `json:"-"` |
| } |
| |
| func (m *AllocateIdsResponse) Reset() { *m = AllocateIdsResponse{} } |
| func (m *AllocateIdsResponse) String() string { return proto.CompactTextString(m) } |
| func (*AllocateIdsResponse) ProtoMessage() {} |
| |
| func (m *AllocateIdsResponse) GetKey() []*Key { |
| if m != nil { |
| return m.Key |
| } |
| return nil |
| } |
| |
| func init() { |
| proto.RegisterEnum("datastore.EntityResult_ResultType", EntityResult_ResultType_name, EntityResult_ResultType_value) |
| proto.RegisterEnum("datastore.PropertyExpression_AggregationFunction", PropertyExpression_AggregationFunction_name, PropertyExpression_AggregationFunction_value) |
| proto.RegisterEnum("datastore.PropertyOrder_Direction", PropertyOrder_Direction_name, PropertyOrder_Direction_value) |
| proto.RegisterEnum("datastore.CompositeFilter_Operator", CompositeFilter_Operator_name, CompositeFilter_Operator_value) |
| proto.RegisterEnum("datastore.PropertyFilter_Operator", PropertyFilter_Operator_name, PropertyFilter_Operator_value) |
| proto.RegisterEnum("datastore.QueryResultBatch_MoreResultsType", QueryResultBatch_MoreResultsType_name, QueryResultBatch_MoreResultsType_value) |
| proto.RegisterEnum("datastore.ReadOptions_ReadConsistency", ReadOptions_ReadConsistency_name, ReadOptions_ReadConsistency_value) |
| proto.RegisterEnum("datastore.BeginTransactionRequest_IsolationLevel", BeginTransactionRequest_IsolationLevel_name, BeginTransactionRequest_IsolationLevel_value) |
| proto.RegisterEnum("datastore.CommitRequest_Mode", CommitRequest_Mode_name, CommitRequest_Mode_value) |
| } |