cadey
/
route
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
route/vendor/gopkg.in/gorethink/gorethink.v2/ql2/ql2.pb.go

1682 lines
52 KiB
Go
Raw Blame History

// Code generated by protoc-gen-go.
// source: ql2.proto
// DO NOT EDIT!
/*
Package ql2 is a generated protocol buffer package.
It is generated from these files:
ql2.proto
It has these top-level messages:
VersionDummy
Query
Frame
Backtrace
Response
Datum
Term
*/
package ql2
import proto "github.com/golang/protobuf/proto"
import json "encoding/json"
import math "math"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = &json.SyntaxError{}
var _ = math.Inf
// non-conforming protobuf libraries
// This enum contains the magic numbers for your version. See **THE HIGH-LEVEL
// VIEW** for what to do with it.
type VersionDummy_Version int32
const (
VersionDummy_V0_1 VersionDummy_Version = 1063369270
VersionDummy_V0_2 VersionDummy_Version = 1915781601
VersionDummy_V0_3 VersionDummy_Version = 1601562686
VersionDummy_V0_4 VersionDummy_Version = 1074539808
VersionDummy_V1_0 VersionDummy_Version = 885177795
)
var VersionDummy_Version_name = map[int32]string{
1063369270: "V0_1",
1915781601: "V0_2",
1601562686: "V0_3",
1074539808: "V0_4",
885177795: "V1_0",
}
var VersionDummy_Version_value = map[string]int32{
"V0_1": 1063369270,
"V0_2": 1915781601,
"V0_3": 1601562686,
"V0_4": 1074539808,
"V1_0": 885177795,
}
func (x VersionDummy_Version) Enum() *VersionDummy_Version {
p := new(VersionDummy_Version)
*p = x
return p
}
func (x VersionDummy_Version) String() string {
return proto.EnumName(VersionDummy_Version_name, int32(x))
}
func (x VersionDummy_Version) MarshalJSON() ([]byte, error) {
return json.Marshal(x.String())
}
func (x *VersionDummy_Version) UnmarshalJSON(data []byte) error {
value, err := proto.UnmarshalJSONEnum(VersionDummy_Version_value, data, "VersionDummy_Version")
if err != nil {
return err
}
*x = VersionDummy_Version(value)
return nil
}
// The protocol to use after the handshake, specified in V0_3
type VersionDummy_Protocol int32
const (
VersionDummy_PROTOBUF VersionDummy_Protocol = 656407617
VersionDummy_JSON VersionDummy_Protocol = 2120839367
)
var VersionDummy_Protocol_name = map[int32]string{
656407617: "PROTOBUF",
2120839367: "JSON",
}
var VersionDummy_Protocol_value = map[string]int32{
"PROTOBUF": 656407617,
"JSON": 2120839367,
}
func (x VersionDummy_Protocol) Enum() *VersionDummy_Protocol {
p := new(VersionDummy_Protocol)
*p = x
return p
}
func (x VersionDummy_Protocol) String() string {
return proto.EnumName(VersionDummy_Protocol_name, int32(x))
}
func (x VersionDummy_Protocol) MarshalJSON() ([]byte, error) {
return json.Marshal(x.String())
}
func (x *VersionDummy_Protocol) UnmarshalJSON(data []byte) error {
value, err := proto.UnmarshalJSONEnum(VersionDummy_Protocol_value, data, "VersionDummy_Protocol")
if err != nil {
return err
}
*x = VersionDummy_Protocol(value)
return nil
}
type Query_QueryType int32
const (
Query_START Query_QueryType = 1
Query_CONTINUE Query_QueryType = 2
// (see [Response]).
Query_STOP Query_QueryType = 3
Query_NOREPLY_WAIT Query_QueryType = 4
Query_SERVER_INFO Query_QueryType = 5
)
var Query_QueryType_name = map[int32]string{
1: "START",
2: "CONTINUE",
3: "STOP",
4: "NOREPLY_WAIT",
5: "SERVER_INFO",
}
var Query_QueryType_value = map[string]int32{
"START": 1,
"CONTINUE": 2,
"STOP": 3,
"NOREPLY_WAIT": 4,
"SERVER_INFO": 5,
}
func (x Query_QueryType) Enum() *Query_QueryType {
p := new(Query_QueryType)
*p = x
return p
}
func (x Query_QueryType) String() string {
return proto.EnumName(Query_QueryType_name, int32(x))
}
func (x Query_QueryType) MarshalJSON() ([]byte, error) {
return json.Marshal(x.String())
}
func (x *Query_QueryType) UnmarshalJSON(data []byte) error {
value, err := proto.UnmarshalJSONEnum(Query_QueryType_value, data, "Query_QueryType")
if err != nil {
return err
}
*x = Query_QueryType(value)
return nil
}
type Frame_FrameType int32
const (
Frame_POS Frame_FrameType = 1
Frame_OPT Frame_FrameType = 2
)
var Frame_FrameType_name = map[int32]string{
1: "POS",
2: "OPT",
}
var Frame_FrameType_value = map[string]int32{
"POS": 1,
"OPT": 2,
}
func (x Frame_FrameType) Enum() *Frame_FrameType {
p := new(Frame_FrameType)
*p = x
return p
}
func (x Frame_FrameType) String() string {
return proto.EnumName(Frame_FrameType_name, int32(x))
}
func (x Frame_FrameType) MarshalJSON() ([]byte, error) {
return json.Marshal(x.String())
}
func (x *Frame_FrameType) UnmarshalJSON(data []byte) error {
value, err := proto.UnmarshalJSONEnum(Frame_FrameType_value, data, "Frame_FrameType")
if err != nil {
return err
}
*x = Frame_FrameType(value)
return nil
}
type Response_ResponseType int32
const (
// These response types indicate success.
Response_SUCCESS_ATOM Response_ResponseType = 1
Response_SUCCESS_SEQUENCE Response_ResponseType = 2
Response_SUCCESS_PARTIAL Response_ResponseType = 3
// datatypes. If you send a [CONTINUE] query with
// the same token as this response, you will get
// more of the sequence. Keep sending [CONTINUE]
// queries until you get back [SUCCESS_SEQUENCE].
Response_WAIT_COMPLETE Response_ResponseType = 4
Response_SERVER_INFO Response_ResponseType = 5
// These response types indicate failure.
Response_CLIENT_ERROR Response_ResponseType = 16
// client sends a malformed protobuf, or tries to
// send [CONTINUE] for an unknown token.
Response_COMPILE_ERROR Response_ResponseType = 17
// checking. For example, if you pass too many
// arguments to a function.
Response_RUNTIME_ERROR Response_ResponseType = 18
)
var Response_ResponseType_name = map[int32]string{
1: "SUCCESS_ATOM",
2: "SUCCESS_SEQUENCE",
3: "SUCCESS_PARTIAL",
4: "WAIT_COMPLETE",
5: "SERVER_INFO",
16: "CLIENT_ERROR",
17: "COMPILE_ERROR",
18: "RUNTIME_ERROR",
}
var Response_ResponseType_value = map[string]int32{
"SUCCESS_ATOM": 1,
"SUCCESS_SEQUENCE": 2,
"SUCCESS_PARTIAL": 3,
"WAIT_COMPLETE": 4,
"SERVER_INFO": 5,
"CLIENT_ERROR": 16,
"COMPILE_ERROR": 17,
"RUNTIME_ERROR": 18,
}
func (x Response_ResponseType) Enum() *Response_ResponseType {
p := new(Response_ResponseType)
*p = x
return p
}
func (x Response_ResponseType) String() string {
return proto.EnumName(Response_ResponseType_name, int32(x))
}
func (x Response_ResponseType) MarshalJSON() ([]byte, error) {
return json.Marshal(x.String())
}
func (x *Response_ResponseType) UnmarshalJSON(data []byte) error {
value, err := proto.UnmarshalJSONEnum(Response_ResponseType_value, data, "Response_ResponseType")
if err != nil {
return err
}
*x = Response_ResponseType(value)
return nil
}
// If `ResponseType` is `RUNTIME_ERROR`, this may be filled in with more
// information about the error.
type Response_ErrorType int32
const (
Response_INTERNAL Response_ErrorType = 1000000
Response_RESOURCE_LIMIT Response_ErrorType = 2000000
Response_QUERY_LOGIC Response_ErrorType = 3000000
Response_NON_EXISTENCE Response_ErrorType = 3100000
Response_OP_FAILED Response_ErrorType = 4100000
Response_OP_INDETERMINATE Response_ErrorType = 4200000
Response_USER Response_ErrorType = 5000000
Response_PERMISSION_ERROR Response_ErrorType = 6000000
)
var Response_ErrorType_name = map[int32]string{
1000000: "INTERNAL",
2000000: "RESOURCE_LIMIT",
3000000: "QUERY_LOGIC",
3100000: "NON_EXISTENCE",
4100000: "OP_FAILED",
4200000: "OP_INDETERMINATE",
5000000: "USER",
6000000: "PERMISSION_ERROR",
}
var Response_ErrorType_value = map[string]int32{
"INTERNAL": 1000000,
"RESOURCE_LIMIT": 2000000,
"QUERY_LOGIC": 3000000,
"NON_EXISTENCE": 3100000,
"OP_FAILED": 4100000,
"OP_INDETERMINATE": 4200000,
"USER": 5000000,
"PERMISSION_ERROR": 6000000,
}
func (x Response_ErrorType) Enum() *Response_ErrorType {
p := new(Response_ErrorType)
*p = x
return p
}
func (x Response_ErrorType) String() string {
return proto.EnumName(Response_ErrorType_name, int32(x))
}
func (x Response_ErrorType) MarshalJSON() ([]byte, error) {
return json.Marshal(x.String())
}
func (x *Response_ErrorType) UnmarshalJSON(data []byte) error {
value, err := proto.UnmarshalJSONEnum(Response_ErrorType_value, data, "Response_ErrorType")
if err != nil {
return err
}
*x = Response_ErrorType(value)
return nil
}
// ResponseNotes are used to provide information about the query
// response that may be useful for people writing drivers or ORMs.
// Currently all the notes we send indicate that a stream has certain
// special properties.
type Response_ResponseNote int32
const (
// The stream is a changefeed stream (e.g. `r.table('test').changes()`).
Response_SEQUENCE_FEED Response_ResponseNote = 1
// The stream is a point changefeed stream
// (e.g. `r.table('test').get(0).changes()`).
Response_ATOM_FEED Response_ResponseNote = 2
// The stream is an order_by_limit changefeed stream
// (e.g. `r.table('test').order_by(index: 'id').limit(5).changes()`).
Response_ORDER_BY_LIMIT_FEED Response_ResponseNote = 3
// The stream is a union of multiple changefeed types that can't be
// collapsed to a single type
// (e.g. `r.table('test').changes().union(r.table('test').get(0).changes())`).
Response_UNIONED_FEED Response_ResponseNote = 4
// The stream is a changefeed stream and includes notes on what state
// the changefeed stream is in (e.g. objects of the form `{state:
// 'initializing'}`).
Response_INCLUDES_STATES Response_ResponseNote = 5
)
var Response_ResponseNote_name = map[int32]string{
1: "SEQUENCE_FEED",
2: "ATOM_FEED",
3: "ORDER_BY_LIMIT_FEED",
4: "UNIONED_FEED",
5: "INCLUDES_STATES",
}
var Response_ResponseNote_value = map[string]int32{
"SEQUENCE_FEED": 1,
"ATOM_FEED": 2,
"ORDER_BY_LIMIT_FEED": 3,
"UNIONED_FEED": 4,
"INCLUDES_STATES": 5,
}
func (x Response_ResponseNote) Enum() *Response_ResponseNote {
p := new(Response_ResponseNote)
*p = x
return p
}
func (x Response_ResponseNote) String() string {
return proto.EnumName(Response_ResponseNote_name, int32(x))
}
func (x Response_ResponseNote) MarshalJSON() ([]byte, error) {
return json.Marshal(x.String())
}
func (x *Response_ResponseNote) UnmarshalJSON(data []byte) error {
value, err := proto.UnmarshalJSONEnum(Response_ResponseNote_value, data, "Response_ResponseNote")
if err != nil {
return err
}
*x = Response_ResponseNote(value)
return nil
}
type Datum_DatumType int32
const (
Datum_R_NULL Datum_DatumType = 1
Datum_R_BOOL Datum_DatumType = 2
Datum_R_NUM Datum_DatumType = 3
Datum_R_STR Datum_DatumType = 4
Datum_R_ARRAY Datum_DatumType = 5
Datum_R_OBJECT Datum_DatumType = 6
// This [DatumType] will only be used if [accepts_r_json] is
// set to [true] in [Query]. [r_str] will be filled with a
// JSON encoding of the [Datum].
Datum_R_JSON Datum_DatumType = 7
)
var Datum_DatumType_name = map[int32]string{
1: "R_NULL",
2: "R_BOOL",
3: "R_NUM",
4: "R_STR",
5: "R_ARRAY",
6: "R_OBJECT",
7: "R_JSON",
}
var Datum_DatumType_value = map[string]int32{
"R_NULL": 1,
"R_BOOL": 2,
"R_NUM": 3,
"R_STR": 4,
"R_ARRAY": 5,
"R_OBJECT": 6,
"R_JSON": 7,
}
func (x Datum_DatumType) Enum() *Datum_DatumType {
p := new(Datum_DatumType)
*p = x
return p
}
func (x Datum_DatumType) String() string {
return proto.EnumName(Datum_DatumType_name, int32(x))
}
func (x Datum_DatumType) MarshalJSON() ([]byte, error) {
return json.Marshal(x.String())
}
func (x *Datum_DatumType) UnmarshalJSON(data []byte) error {
value, err := proto.UnmarshalJSONEnum(Datum_DatumType_value, data, "Datum_DatumType")
if err != nil {
return err
}
*x = Datum_DatumType(value)
return nil
}
type Term_TermType int32
const (
// A RQL datum, stored in `datum` below.
Term_DATUM Term_TermType = 1
Term_MAKE_ARRAY Term_TermType = 2
// Evaluate the terms in [optargs] and make an object
Term_MAKE_OBJ Term_TermType = 3
// Takes an integer representing a variable and returns the value stored
// in that variable. It's the responsibility of the client to translate
// from their local representation of a variable to a unique _non-negative_
// integer for that variable. (We do it this way instead of letting
// clients provide variable names as strings to discourage
// variable-capturing client libraries, and because it's more efficient
// on the wire.)
Term_VAR Term_TermType = 10
// Takes some javascript code and executes it.
Term_JAVASCRIPT Term_TermType = 11
// STRING {timeout: !NUMBER} -> Function(*)
Term_UUID Term_TermType = 169
// Takes an HTTP URL and gets it. If the get succeeds and
// returns valid JSON, it is converted into a DATUM
Term_HTTP Term_TermType = 153
// Takes a string and throws an error with that message.
// Inside of a `default` block, you can omit the first
// argument to rethrow whatever error you catch (this is most
// useful as an argument to the `default` filter optarg).
Term_ERROR Term_TermType = 12
// Takes nothing and returns a reference to the implicit variable.
Term_IMPLICIT_VAR Term_TermType = 13
// * Data Operators
// Returns a reference to a database.
Term_DB Term_TermType = 14
// Returns a reference to a table.
Term_TABLE Term_TermType = 15
// STRING, {read_mode:STRING, identifier_format:STRING} -> Table
// Gets a single element from a table by its primary or a secondary key.
Term_GET Term_TermType = 16
// Table, STRING -> NULL | Table, NUMBER -> NULL |
Term_GET_ALL Term_TermType = 78
// Simple DATUM Ops
Term_EQ Term_TermType = 17
Term_NE Term_TermType = 18
Term_LT Term_TermType = 19
Term_LE Term_TermType = 20
Term_GT Term_TermType = 21
Term_GE Term_TermType = 22
Term_NOT Term_TermType = 23
// ADD can either add two numbers or concatenate two arrays.
Term_ADD Term_TermType = 24
Term_SUB Term_TermType = 25
Term_MUL Term_TermType = 26
Term_DIV Term_TermType = 27
Term_MOD Term_TermType = 28
Term_FLOOR Term_TermType = 183
Term_CEIL Term_TermType = 184
Term_ROUND Term_TermType = 185
// DATUM Array Ops
// Append a single element to the end of an array (like `snoc`).
Term_APPEND Term_TermType = 29
// Prepend a single element to the end of an array (like `cons`).
Term_PREPEND Term_TermType = 80
// Remove the elements of one array from another array.
Term_DIFFERENCE Term_TermType = 95
// DATUM Set Ops
// Set ops work on arrays. They don't use actual sets and thus have
// performance characteristics you would expect from arrays rather than
// from sets. All set operations have the post condition that they
// array they return contains no duplicate values.
Term_SET_INSERT Term_TermType = 88
Term_SET_INTERSECTION Term_TermType = 89
Term_SET_UNION Term_TermType = 90
Term_SET_DIFFERENCE Term_TermType = 91
Term_SLICE Term_TermType = 30
Term_SKIP Term_TermType = 70
Term_LIMIT Term_TermType = 71
Term_OFFSETS_OF Term_TermType = 87
Term_CONTAINS Term_TermType = 93
// Stream/Object Ops
// Get a particular field from an object, or map that over a
// sequence.
Term_GET_FIELD Term_TermType = 31
// | Sequence, STRING -> Sequence
// Return an array containing the keys of the object.
Term_KEYS Term_TermType = 94
// Return an array containing the values of the object.
Term_VALUES Term_TermType = 186
// Creates an object
Term_OBJECT Term_TermType = 143
// Check whether an object contains all the specified fields,
// or filters a sequence so that all objects inside of it
// contain all the specified fields.
Term_HAS_FIELDS Term_TermType = 32
// x.with_fields(...) <=> x.has_fields(...).pluck(...)
Term_WITH_FIELDS Term_TermType = 96
// Get a subset of an object by selecting some attributes to preserve,
// or map that over a sequence. (Both pick and pluck, polymorphic.)
Term_PLUCK Term_TermType = 33
// Get a subset of an object by selecting some attributes to discard, or
// map that over a sequence. (Both unpick and without, polymorphic.)
Term_WITHOUT Term_TermType = 34
// Merge objects (right-preferential)
Term_MERGE Term_TermType = 35
// Sequence Ops
// Get all elements of a sequence between two values.
// Half-open by default, but the openness of either side can be
// changed by passing 'closed' or 'open for `right_bound` or
// `left_bound`.
Term_BETWEEN_DEPRECATED Term_TermType = 36
// With the newer version, clients should use `r.minval` and `r.maxval` for unboundedness
Term_BETWEEN Term_TermType = 182
Term_REDUCE Term_TermType = 37
Term_MAP Term_TermType = 38
Term_FOLD Term_TermType = 187
// Filter a sequence with either a function or a shortcut
// object (see API docs for details). The body of FILTER is
// wrapped in an implicit `.default(false)`, and you can
// change the default value by specifying the `default`
// optarg. If you make the default `r.error`, all errors
// caught by `default` will be rethrown as if the `default`
// did not exist.
Term_FILTER Term_TermType = 39
// Sequence, OBJECT, {default:DATUM} -> Sequence
// Map a function over a sequence and then concatenate the results together.
Term_CONCAT_MAP Term_TermType = 40
// Order a sequence based on one or more attributes.
Term_ORDER_BY Term_TermType = 41
// Get all distinct elements of a sequence (like `uniq`).
Term_DISTINCT Term_TermType = 42
// Count the number of elements in a sequence, or only the elements that match
// a given filter.
Term_COUNT Term_TermType = 43
Term_IS_EMPTY Term_TermType = 86
// Take the union of multiple sequences (preserves duplicate elements! (use distinct)).
Term_UNION Term_TermType = 44
// Get the Nth element of a sequence.
Term_NTH Term_TermType = 45
// do NTH or GET_FIELD depending on target object
Term_BRACKET Term_TermType = 170
Term_INNER_JOIN Term_TermType = 48
Term_OUTER_JOIN Term_TermType = 49
// An inner-join that does an equality comparison on two attributes.
Term_EQ_JOIN Term_TermType = 50
Term_ZIP Term_TermType = 72
Term_RANGE Term_TermType = 173
// Array Ops
// Insert an element in to an array at a given index.
Term_INSERT_AT Term_TermType = 82
// Remove an element at a given index from an array.
Term_DELETE_AT Term_TermType = 83
// ARRAY, NUMBER, NUMBER -> ARRAY
// Change the element at a given index of an array.
Term_CHANGE_AT Term_TermType = 84
// Splice one array in to another array.
Term_SPLICE_AT Term_TermType = 85
// * Type Ops
// Coerces a datum to a named type (e.g. "bool").
// If you previously used `stream_to_array`, you should use this instead
// with the type "array".
Term_COERCE_TO Term_TermType = 51
// Returns the named type of a datum (e.g. TYPE_OF(true) = "BOOL")
Term_TYPE_OF Term_TermType = 52
// * Write Ops (the OBJECTs contain data about number of errors etc.)
// Updates all the rows in a selection. Calls its Function with the row
// to be updated, and then merges the result of that call.
Term_UPDATE Term_TermType = 53
// SingleSelection, Function(1), {non_atomic:BOOL, durability:STRING, return_changes:BOOL} -> OBJECT |
// StreamSelection, OBJECT, {non_atomic:BOOL, durability:STRING, return_changes:BOOL} -> OBJECT |
// SingleSelection, OBJECT, {non_atomic:BOOL, durability:STRING, return_changes:BOOL} -> OBJECT
// Deletes all the rows in a selection.
Term_DELETE Term_TermType = 54
// Replaces all the rows in a selection. Calls its Function with the row
// to be replaced, and then discards it and stores the result of that
// call.
Term_REPLACE Term_TermType = 55
// Inserts into a table. If `conflict` is replace, overwrites
// entries with the same primary key. If `conflict` is
// update, does an update on the entry. If `conflict` is
// error, or is omitted, conflicts will trigger an error.
Term_INSERT Term_TermType = 56
// * Administrative OPs
// Creates a database with a particular name.
Term_DB_CREATE Term_TermType = 57
// Drops a database with a particular name.
Term_DB_DROP Term_TermType = 58
// Lists all the databases by name. (Takes no arguments)
Term_DB_LIST Term_TermType = 59
// Creates a table with a particular name in a particular
// database. (You may omit the first argument to use the
// default database.)
Term_TABLE_CREATE Term_TermType = 60
// Database, STRING, {primary_key:STRING, shards:NUMBER, replicas:OBJECT, primary_replica_tag:STRING} -> OBJECT
// STRING, {primary_key:STRING, shards:NUMBER, replicas:NUMBER, primary_replica_tag:STRING} -> OBJECT
// STRING, {primary_key:STRING, shards:NUMBER, replicas:OBJECT, primary_replica_tag:STRING} -> OBJECT
// Drops a table with a particular name from a particular
// database. (You may omit the first argument to use the
// default database.)
Term_TABLE_DROP Term_TermType = 61
// STRING -> OBJECT
// Lists all the tables in a particular database. (You may
// omit the first argument to use the default database.)
Term_TABLE_LIST Term_TermType = 62
// -> ARRAY
// Returns the row in the `rethinkdb.table_config` or `rethinkdb.db_config` table
// that corresponds to the given database or table.
Term_CONFIG Term_TermType = 174
// Table -> SingleSelection
// Returns the row in the `rethinkdb.table_status` table that corresponds to the
// given table.
Term_STATUS Term_TermType = 175
// Called on a table, waits for that table to be ready for read/write operations.
// Called on a database, waits for all of the tables in the database to be ready.
// Returns the corresponding row or rows from the `rethinkdb.table_status` table.
Term_WAIT Term_TermType = 177
// Database -> OBJECT
// Generates a new config for the given table, or all tables in the given database
// The `shards` and `replicas` arguments are required. If `emergency_repair` is
// specified, it will enter a completely different mode of repairing a table
// which has lost half or more of its replicas.
Term_RECONFIGURE Term_TermType = 176
// dry_run:BOOLEAN]
// } -> OBJECT
// Database|Table, {shards:NUMBER, replicas:OBJECT [,
// primary_replica_tag:STRING,
// nonvoting_replica_tags:ARRAY,
// dry_run:BOOLEAN]
// } -> OBJECT
// Table, {emergency_repair:STRING, dry_run:BOOLEAN} -> OBJECT
// Balances the table's shards but leaves everything else the same. Can also be
// applied to an entire database at once.
Term_REBALANCE Term_TermType = 179
// Ensures that previously issued soft-durability writes are complete and
// written to disk.
Term_SYNC Term_TermType = 138
// Set global, database, or table-specific permissions
Term_GRANT Term_TermType = 188
// * Secondary indexes OPs
// Creates a new secondary index with a particular name and definition.
Term_INDEX_CREATE Term_TermType = 75
// Drops a secondary index with a particular name from the specified table.
Term_INDEX_DROP Term_TermType = 76
// Lists all secondary indexes on a particular table.
Term_INDEX_LIST Term_TermType = 77
// Gets information about whether or not a set of indexes are ready to
// be accessed. Returns a list of objects that look like this:
// {index:STRING, ready:BOOL[, progress:NUMBER]}
Term_INDEX_STATUS Term_TermType = 139
// Blocks until a set of indexes are ready to be accessed. Returns the
// same values INDEX_STATUS.
Term_INDEX_WAIT Term_TermType = 140
// Renames the given index to a new name
Term_INDEX_RENAME Term_TermType = 156
// * Control Operators
// Calls a function on data
Term_FUNCALL Term_TermType = 64
// Executes its first argument, and returns its second argument if it
// got [true] or its third argument if it got [false] (like an `if`
// statement).
Term_BRANCH Term_TermType = 65
// Returns true if any of its arguments returns true (short-circuits).
Term_OR Term_TermType = 66
// Returns true if all of its arguments return true (short-circuits).
Term_AND Term_TermType = 67
// Calls its Function with each entry in the sequence
// and executes the array of terms that Function returns.
Term_FOR_EACH Term_TermType = 68
// An anonymous function. Takes an array of numbers representing
// variables (see [VAR] above), and a [Term] to execute with those in
// scope. Returns a function that may be passed an array of arguments,
// then executes the Term with those bound to the variable names. The
// user will never construct this directly. We use it internally for
// things like `map` which take a function. The "arity" of a [Function] is
// the number of arguments it takes.
// For example, here's what `_X_.map{|x| x+2}` turns into:
// Term {
// type = MAP;
// args = [_X_,
// Term {
// type = Function;
// args = [Term {
// type = DATUM;
// datum = Datum {
// type = R_ARRAY;
// r_array = [Datum { type = R_NUM; r_num = 1; }];
// };
// },
// Term {
// type = ADD;
// args = [Term {
// type = VAR;
// args = [Term {
// type = DATUM;
// datum = Datum { type = R_NUM;
// r_num = 1};
// }];
// },
// Term {
// type = DATUM;
// datum = Datum { type = R_NUM; r_num = 2; };
// }];
// }];
// }];
Term_FUNC Term_TermType = 69
// Indicates to ORDER_BY that this attribute is to be sorted in ascending order.
Term_ASC Term_TermType = 73
// Indicates to ORDER_BY that this attribute is to be sorted in descending order.
Term_DESC Term_TermType = 74
// Gets info about anything. INFO is most commonly called on tables.
Term_INFO Term_TermType = 79
// `a.match(b)` returns a match object if the string `a`
// matches the regular expression `b`.
Term_MATCH Term_TermType = 97
// Change the case of a string.
Term_UPCASE Term_TermType = 141
Term_DOWNCASE Term_TermType = 142
// Select a number of elements from sequence with uniform distribution.
Term_SAMPLE Term_TermType = 81
// Evaluates its first argument. If that argument returns
// NULL or throws an error related to the absence of an
// expected value (for instance, accessing a non-existent
// field or adding NULL to an integer), DEFAULT will either
// return its second argument or execute it if it's a
// function. If the second argument is a function, it will be
// passed either the text of the error or NULL as its
// argument.
Term_DEFAULT Term_TermType = 92
// Parses its first argument as a json string and returns it as a
// datum.
Term_JSON Term_TermType = 98
// Returns the datum as a JSON string.
// N.B.: we would really prefer this be named TO_JSON and that exists as
// an alias in Python and JavaScript drivers; however it conflicts with the
// standard `to_json` method defined by Ruby's standard json library.
Term_TO_JSON_STRING Term_TermType = 172
// Parses its first arguments as an ISO 8601 time and returns it as a
// datum.
Term_ISO8601 Term_TermType = 99
// Prints a time as an ISO 8601 time.
Term_TO_ISO8601 Term_TermType = 100
// Returns a time given seconds since epoch in UTC.
Term_EPOCH_TIME Term_TermType = 101
// Returns seconds since epoch in UTC given a time.
Term_TO_EPOCH_TIME Term_TermType = 102
// The time the query was received by the server.
Term_NOW Term_TermType = 103
// Puts a time into an ISO 8601 timezone.
Term_IN_TIMEZONE Term_TermType = 104
// a.during(b, c) returns whether a is in the range [b, c)
Term_DURING Term_TermType = 105
// Retrieves the date portion of a time.
Term_DATE Term_TermType = 106
// x.time_of_day == x.date - x
Term_TIME_OF_DAY Term_TermType = 126
// Returns the timezone of a time.
Term_TIMEZONE Term_TermType = 127
// These access the various components of a time.
Term_YEAR Term_TermType = 128
Term_MONTH Term_TermType = 129
Term_DAY Term_TermType = 130
Term_DAY_OF_WEEK Term_TermType = 131
Term_DAY_OF_YEAR Term_TermType = 132
Term_HOURS Term_TermType = 133
Term_MINUTES Term_TermType = 134
Term_SECONDS Term_TermType = 135
// Construct a time from a date and optional timezone or a
// date+time and optional timezone.
Term_TIME Term_TermType = 136
// Constants for ISO 8601 days of the week.
Term_MONDAY Term_TermType = 107
Term_TUESDAY Term_TermType = 108
Term_WEDNESDAY Term_TermType = 109
Term_THURSDAY Term_TermType = 110
Term_FRIDAY Term_TermType = 111
Term_SATURDAY Term_TermType = 112
Term_SUNDAY Term_TermType = 113
// Constants for ISO 8601 months.
Term_JANUARY Term_TermType = 114
Term_FEBRUARY Term_TermType = 115
Term_MARCH Term_TermType = 116
Term_APRIL Term_TermType = 117
Term_MAY Term_TermType = 118
Term_JUNE Term_TermType = 119
Term_JULY Term_TermType = 120
Term_AUGUST Term_TermType = 121
Term_SEPTEMBER Term_TermType = 122
Term_OCTOBER Term_TermType = 123
Term_NOVEMBER Term_TermType = 124
Term_DECEMBER Term_TermType = 125
// Indicates to MERGE to replace, or remove in case of an empty literal, the
// other object rather than merge it.
Term_LITERAL Term_TermType = 137
// SEQUENCE, STRING -> GROUPED_SEQUENCE | SEQUENCE, FUNCTION -> GROUPED_SEQUENCE
Term_GROUP Term_TermType = 144
Term_SUM Term_TermType = 145
Term_AVG Term_TermType = 146
Term_MIN Term_TermType = 147
Term_MAX Term_TermType = 148
// `str.split()` splits on whitespace
// `str.split(" ")` splits on spaces only
// `str.split(" ", 5)` splits on spaces with at most 5 results
// `str.split(nil, 5)` splits on whitespace with at most 5 results
Term_SPLIT Term_TermType = 149
Term_UNGROUP Term_TermType = 150
// Takes a range of numbers and returns a random number within the range
Term_RANDOM Term_TermType = 151
Term_CHANGES Term_TermType = 152
Term_ARGS Term_TermType = 154
// BINARY is client-only at the moment, it is not supported on the server
Term_BINARY Term_TermType = 155
Term_GEOJSON Term_TermType = 157
Term_TO_GEOJSON Term_TermType = 158
Term_POINT Term_TermType = 159
Term_LINE Term_TermType = 160
Term_POLYGON Term_TermType = 161
Term_DISTANCE Term_TermType = 162
Term_INTERSECTS Term_TermType = 163
Term_INCLUDES Term_TermType = 164
Term_CIRCLE Term_TermType = 165
Term_GET_INTERSECTING Term_TermType = 166
Term_FILL Term_TermType = 167
Term_GET_NEAREST Term_TermType = 168
Term_POLYGON_SUB Term_TermType = 171
// Constants for specifying key ranges
Term_MINVAL Term_TermType = 180
Term_MAXVAL Term_TermType = 181
)
var Term_TermType_name = map[int32]string{
1: "DATUM",
2: "MAKE_ARRAY",
3: "MAKE_OBJ",
10: "VAR",
11: "JAVASCRIPT",
169: "UUID",
153: "HTTP",
12: "ERROR",
13: "IMPLICIT_VAR",
14: "DB",
15: "TABLE",
16: "GET",
78: "GET_ALL",
17: "EQ",
18: "NE",
19: "LT",
20: "LE",
21: "GT",
22: "GE",
23: "NOT",
24: "ADD",
25: "SUB",
26: "MUL",
27: "DIV",
28: "MOD",
183: "FLOOR",
184: "CEIL",
185: "ROUND",
29: "APPEND",
80: "PREPEND",
95: "DIFFERENCE",
88: "SET_INSERT",
89: "SET_INTERSECTION",
90: "SET_UNION",
91: "SET_DIFFERENCE",
30: "SLICE",
70: "SKIP",
71: "LIMIT",
87: "OFFSETS_OF",
93: "CONTAINS",
31: "GET_FIELD",
94: "KEYS",
186: "VALUES",
143: "OBJECT",
32: "HAS_FIELDS",
96: "WITH_FIELDS",
33: "PLUCK",
34: "WITHOUT",
35: "MERGE",
36: "BETWEEN_DEPRECATED",
182: "BETWEEN",
37: "REDUCE",
38: "MAP",
187: "FOLD",
39: "FILTER",
40: "CONCAT_MAP",
41: "ORDER_BY",
42: "DISTINCT",
43: "COUNT",
86: "IS_EMPTY",
44: "UNION",
45: "NTH",
170: "BRACKET",
48: "INNER_JOIN",
49: "OUTER_JOIN",
50: "EQ_JOIN",
72: "ZIP",
173: "RANGE",
82: "INSERT_AT",
83: "DELETE_AT",
84: "CHANGE_AT",
85: "SPLICE_AT",
51: "COERCE_TO",
52: "TYPE_OF",
53: "UPDATE",
54: "DELETE",
55: "REPLACE",
56: "INSERT",
57: "DB_CREATE",
58: "DB_DROP",
59: "DB_LIST",
60: "TABLE_CREATE",
61: "TABLE_DROP",
62: "TABLE_LIST",
174: "CONFIG",
175: "STATUS",
177: "WAIT",
176: "RECONFIGURE",
179: "REBALANCE",
138: "SYNC",
188: "GRANT",
75: "INDEX_CREATE",
76: "INDEX_DROP",
77: "INDEX_LIST",
139: "INDEX_STATUS",
140: "INDEX_WAIT",
156: "INDEX_RENAME",
64: "FUNCALL",
65: "BRANCH",
66: "OR",
67: "AND",
68: "FOR_EACH",
69: "FUNC",
73: "ASC",
74: "DESC",
79: "INFO",
97: "MATCH",
141: "UPCASE",
142: "DOWNCASE",
81: "SAMPLE",
92: "DEFAULT",
98: "JSON",
172: "TO_JSON_STRING",
99: "ISO8601",
100: "TO_ISO8601",
101: "EPOCH_TIME",
102: "TO_EPOCH_TIME",
103: "NOW",
104: "IN_TIMEZONE",
105: "DURING",
106: "DATE",
126: "TIME_OF_DAY",
127: "TIMEZONE",
128: "YEAR",
129: "MONTH",
130: "DAY",
131: "DAY_OF_WEEK",
132: "DAY_OF_YEAR",
133: "HOURS",
134: "MINUTES",
135: "SECONDS",
136: "TIME",
107: "MONDAY",
108: "TUESDAY",
109: "WEDNESDAY",
110: "THURSDAY",
111: "FRIDAY",
112: "SATURDAY",
113: "SUNDAY",
114: "JANUARY",
115: "FEBRUARY",
116: "MARCH",
117: "APRIL",
118: "MAY",
119: "JUNE",
120: "JULY",
121: "AUGUST",
122: "SEPTEMBER",
123: "OCTOBER",
124: "NOVEMBER",
125: "DECEMBER",
137: "LITERAL",
144: "GROUP",
145: "SUM",
146: "AVG",
147: "MIN",
148: "MAX",
149: "SPLIT",
150: "UNGROUP",
151: "RANDOM",
152: "CHANGES",
154: "ARGS",
155: "BINARY",
157: "GEOJSON",
158: "TO_GEOJSON",
159: "POINT",
160: "LINE",
161: "POLYGON",
162: "DISTANCE",
163: "INTERSECTS",
164: "INCLUDES",
165: "CIRCLE",
166: "GET_INTERSECTING",
167: "FILL",
168: "GET_NEAREST",
171: "POLYGON_SUB",
180: "MINVAL",
181: "MAXVAL",
}
var Term_TermType_value = map[string]int32{
"DATUM": 1,
"MAKE_ARRAY": 2,
"MAKE_OBJ": 3,
"VAR": 10,
"JAVASCRIPT": 11,
"UUID": 169,
"HTTP": 153,
"ERROR": 12,
"IMPLICIT_VAR": 13,
"DB": 14,
"TABLE": 15,
"GET": 16,
"GET_ALL": 78,
"EQ": 17,
"NE": 18,
"LT": 19,
"LE": 20,
"GT": 21,
"GE": 22,
"NOT": 23,
"ADD": 24,
"SUB": 25,
"MUL": 26,
"DIV": 27,
"MOD": 28,
"FLOOR": 183,
"CEIL": 184,
"ROUND": 185,
"APPEND": 29,
"PREPEND": 80,
"DIFFERENCE": 95,
"SET_INSERT": 88,
"SET_INTERSECTION": 89,
"SET_UNION": 90,
"SET_DIFFERENCE": 91,
"SLICE": 30,
"SKIP": 70,
"LIMIT": 71,
"OFFSETS_OF": 87,
"CONTAINS": 93,
"GET_FIELD": 31,
"KEYS": 94,
"VALUES": 186,
"OBJECT": 143,
"HAS_FIELDS": 32,
"WITH_FIELDS": 96,
"PLUCK": 33,
"WITHOUT": 34,
"MERGE": 35,
"BETWEEN_DEPRECATED": 36,
"BETWEEN": 182,
"REDUCE": 37,
"MAP": 38,
"FOLD": 187,
"FILTER": 39,
"CONCAT_MAP": 40,
"ORDER_BY": 41,
"DISTINCT": 42,
"COUNT": 43,
"IS_EMPTY": 86,
"UNION": 44,
"NTH": 45,
"BRACKET": 170,
"INNER_JOIN": 48,
"OUTER_JOIN": 49,
"EQ_JOIN": 50,
"ZIP": 72,
"RANGE": 173,
"INSERT_AT": 82,
"DELETE_AT": 83,
"CHANGE_AT": 84,
"SPLICE_AT": 85,
"COERCE_TO": 51,
"TYPE_OF": 52,
"UPDATE": 53,
"DELETE": 54,
"REPLACE": 55,
"INSERT": 56,
"DB_CREATE": 57,
"DB_DROP": 58,
"DB_LIST": 59,
"TABLE_CREATE": 60,
"TABLE_DROP": 61,
"TABLE_LIST": 62,
"CONFIG": 174,
"STATUS": 175,
"WAIT": 177,
"RECONFIGURE": 176,
"REBALANCE": 179,
"SYNC": 138,
"GRANT": 188,
"INDEX_CREATE": 75,
"INDEX_DROP": 76,
"INDEX_LIST": 77,
"INDEX_STATUS": 139,
"INDEX_WAIT": 140,
"INDEX_RENAME": 156,
"FUNCALL": 64,
"BRANCH": 65,
"OR": 66,
"AND": 67,
"FOR_EACH": 68,
"FUNC": 69,
"ASC": 73,
"DESC": 74,
"INFO": 79,
"MATCH": 97,
"UPCASE": 141,
"DOWNCASE": 142,
"SAMPLE": 81,
"DEFAULT": 92,
"JSON": 98,
"TO_JSON_STRING": 172,
"ISO8601": 99,
"TO_ISO8601": 100,
"EPOCH_TIME": 101,
"TO_EPOCH_TIME": 102,
"NOW": 103,
"IN_TIMEZONE": 104,
"DURING": 105,
"DATE": 106,
"TIME_OF_DAY": 126,
"TIMEZONE": 127,
"YEAR": 128,
"MONTH": 129,
"DAY": 130,
"DAY_OF_WEEK": 131,
"DAY_OF_YEAR": 132,
"HOURS": 133,
"MINUTES": 134,
"SECONDS": 135,
"TIME": 136,
"MONDAY": 107,
"TUESDAY": 108,
"WEDNESDAY": 109,
"THURSDAY": 110,
"FRIDAY": 111,
"SATURDAY": 112,
"SUNDAY": 113,
"JANUARY": 114,
"FEBRUARY": 115,
"MARCH": 116,
"APRIL": 117,
"MAY": 118,
"JUNE": 119,
"JULY": 120,
"AUGUST": 121,
"SEPTEMBER": 122,
"OCTOBER": 123,
"NOVEMBER": 124,
"DECEMBER": 125,
"LITERAL": 137,
"GROUP": 144,
"SUM": 145,
"AVG": 146,
"MIN": 147,
"MAX": 148,
"SPLIT": 149,
"UNGROUP": 150,
"RANDOM": 151,
"CHANGES": 152,
"ARGS": 154,
"BINARY": 155,
"GEOJSON": 157,
"TO_GEOJSON": 158,
"POINT": 159,
"LINE": 160,
"POLYGON": 161,
"DISTANCE": 162,
"INTERSECTS": 163,
"INCLUDES": 164,
"CIRCLE": 165,
"GET_INTERSECTING": 166,
"FILL": 167,
"GET_NEAREST": 168,
"POLYGON_SUB": 171,
"MINVAL": 180,
"MAXVAL": 181,
}
func (x Term_TermType) Enum() *Term_TermType {
p := new(Term_TermType)
*p = x
return p
}
func (x Term_TermType) String() string {
return proto.EnumName(Term_TermType_name, int32(x))
}
func (x Term_TermType) MarshalJSON() ([]byte, error) {
return json.Marshal(x.String())
}
func (x *Term_TermType) UnmarshalJSON(data []byte) error {
value, err := proto.UnmarshalJSONEnum(Term_TermType_value, data, "Term_TermType")
if err != nil {
return err
}
*x = Term_TermType(value)
return nil
}
type VersionDummy struct {
XXX_unrecognized []byte `json:"-"`
}
func (m *VersionDummy) Reset() { *m = VersionDummy{} }
func (m *VersionDummy) String() string { return proto.CompactTextString(m) }
func (*VersionDummy) ProtoMessage() {}
// You send one of:
// * A [START] query with a [Term] to evaluate and a unique-per-connection token.
// * A [CONTINUE] query with the same token as a [START] query that returned
// [SUCCESS_PARTIAL] in its [Response].
// * A [STOP] query with the same token as a [START] query that you want to stop.
// * A [NOREPLY_WAIT] query with a unique per-connection token. The server answers
// with a [WAIT_COMPLETE] [Response].
// * A [SERVER_INFO] query. The server answers with a [SERVER_INFO] [Response].
type Query struct {
Type *Query_QueryType `protobuf:"varint,1,opt,name=type,enum=Query_QueryType" json:"type,omitempty"`
// A [Term] is how we represent the operations we want a query to perform.
Query *Term `protobuf:"bytes,2,opt,name=query" json:"query,omitempty"`
Token *int64 `protobuf:"varint,3,opt,name=token" json:"token,omitempty"`
// This flag is ignored on the server. `noreply` should be added
// to `global_optargs` instead (the key "noreply" should map to
// either true or false).
OBSOLETENoreply *bool `protobuf:"varint,4,opt,name=OBSOLETE_noreply,def=0" json:"OBSOLETE_noreply,omitempty"`
// If this is set to [true], then [Datum] values will sometimes be
// of [DatumType] [R_JSON] (see below). This can provide enormous
// speedups in languages with poor protobuf libraries.
AcceptsRJson *bool `protobuf:"varint,5,opt,name=accepts_r_json,def=0" json:"accepts_r_json,omitempty"`
GlobalOptargs []*Query_AssocPair `protobuf:"bytes,6,rep,name=global_optargs" json:"global_optargs,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_OBSOLETENoreply bool = false
const Default_Query_AcceptsRJson bool = false
func (m *Query) GetType() Query_QueryType {
if m != nil && m.Type != nil {
return *m.Type
}
return Query_START
}
func (m *Query) GetQuery() *Term {
if m != nil {
return m.Query
}
return nil
}
func (m *Query) GetToken() int64 {
if m != nil && m.Token != nil {
return *m.Token
}
return 0
}
func (m *Query) GetOBSOLETENoreply() bool {
if m != nil && m.OBSOLETENoreply != nil {
return *m.OBSOLETENoreply
}
return Default_Query_OBSOLETENoreply
}
func (m *Query) GetAcceptsRJson() bool {
if m != nil && m.AcceptsRJson != nil {
return *m.AcceptsRJson
}
return Default_Query_AcceptsRJson
}
func (m *Query) GetGlobalOptargs() []*Query_AssocPair {
if m != nil {
return m.GlobalOptargs
}
return nil
}
type Query_AssocPair struct {
Key *string `protobuf:"bytes,1,opt,name=key" json:"key,omitempty"`
Val *Term `protobuf:"bytes,2,opt,name=val" json:"val,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *Query_AssocPair) Reset() { *m = Query_AssocPair{} }
func (m *Query_AssocPair) String() string { return proto.CompactTextString(m) }
func (*Query_AssocPair) ProtoMessage() {}
func (m *Query_AssocPair) GetKey() string {
if m != nil && m.Key != nil {
return *m.Key
}
return ""
}
func (m *Query_AssocPair) GetVal() *Term {
if m != nil {
return m.Val
}
return nil
}
// A backtrace frame (see `backtrace` in Response below)
type Frame struct {
Type *Frame_FrameType `protobuf:"varint,1,opt,name=type,enum=Frame_FrameType" json:"type,omitempty"`
Pos *int64 `protobuf:"varint,2,opt,name=pos" json:"pos,omitempty"`
Opt *string `protobuf:"bytes,3,opt,name=opt" json:"opt,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *Frame) Reset() { *m = Frame{} }
func (m *Frame) String() string { return proto.CompactTextString(m) }
func (*Frame) ProtoMessage() {}
func (m *Frame) GetType() Frame_FrameType {
if m != nil && m.Type != nil {
return *m.Type
}
return Frame_POS
}
func (m *Frame) GetPos() int64 {
if m != nil && m.Pos != nil {
return *m.Pos
}
return 0
}
func (m *Frame) GetOpt() string {
if m != nil && m.Opt != nil {
return *m.Opt
}
return ""
}
type Backtrace struct {
Frames []*Frame `protobuf:"bytes,1,rep,name=frames" json:"frames,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *Backtrace) Reset() { *m = Backtrace{} }
func (m *Backtrace) String() string { return proto.CompactTextString(m) }
func (*Backtrace) ProtoMessage() {}
func (m *Backtrace) GetFrames() []*Frame {
if m != nil {
return m.Frames
}
return nil
}
// You get back a response with the same [token] as your query.
type Response struct {
Type *Response_ResponseType `protobuf:"varint,1,opt,name=type,enum=Response_ResponseType" json:"type,omitempty"`
ErrorType *Response_ErrorType `protobuf:"varint,7,opt,name=error_type,enum=Response_ErrorType" json:"error_type,omitempty"`
Notes []Response_ResponseNote `protobuf:"varint,6,rep,name=notes,enum=Response_ResponseNote" json:"notes,omitempty"`
Token *int64 `protobuf:"varint,2,opt,name=token" json:"token,omitempty"`
// [response] contains 1 RQL datum if [type] is [SUCCESS_ATOM] or
// [SERVER_INFO]. [response] contains many RQL data if [type] is
// [SUCCESS_SEQUENCE] or [SUCCESS_PARTIAL]. [response] contains 1
// error message (of type [R_STR]) in all other cases.
Response []*Datum `protobuf:"bytes,3,rep,name=response" json:"response,omitempty"`
// If [type] is [CLIENT_ERROR], [TYPE_ERROR], or [RUNTIME_ERROR], then a
// backtrace will be provided. The backtrace says where in the query the
// error occurred. Ideally this information will be presented to the user as
// a pretty-printed version of their query with the erroneous section
// underlined. A backtrace is a series of 0 or more [Frame]s, each of which
// specifies either the index of a positional argument or the name of an
// optional argument. (Those words will make more sense if you look at the
// [Term] message below.)
Backtrace *Backtrace `protobuf:"bytes,4,opt,name=backtrace" json:"backtrace,omitempty"`
// If the [global_optargs] in the [Query] that this [Response] is a
// response to contains a key "profile" which maps to a static value of
// true then [profile] will contain a [Datum] which provides profiling
// information about the execution of the query. This field should be
// returned to the user along with the result that would normally be
// returned (a datum or a cursor). In official drivers this is accomplished
// by putting them inside of an object with "value" mapping to the return
// value and "profile" mapping to the profile object.
Profile *Datum `protobuf:"bytes,5,opt,name=profile" json:"profile,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *Response) Reset() { *m = Response{} }
func (m *Response) String() string { return proto.CompactTextString(m) }
func (*Response) ProtoMessage() {}
func (m *Response) GetType() Response_ResponseType {
if m != nil && m.Type != nil {
return *m.Type
}
return Response_SUCCESS_ATOM
}
func (m *Response) GetErrorType() Response_ErrorType {
if m != nil && m.ErrorType != nil {
return *m.ErrorType
}
return Response_INTERNAL
}
func (m *Response) GetNotes() []Response_ResponseNote {
if m != nil {
return m.Notes
}
return nil
}
func (m *Response) GetToken() int64 {
if m != nil && m.Token != nil {
return *m.Token
}
return 0
}
func (m *Response) GetResponse() []*Datum {
if m != nil {
return m.Response
}
return nil
}
func (m *Response) GetBacktrace() *Backtrace {
if m != nil {
return m.Backtrace
}
return nil
}
func (m *Response) GetProfile() *Datum {
if m != nil {
return m.Profile
}
return nil
}
// A [Datum] is a chunk of data that can be serialized to disk or returned to
// the user in a Response. Currently we only support JSON types, but we may
// support other types in the future (e.g., a date type or an integer type).
type Datum struct {
Type *Datum_DatumType `protobuf:"varint,1,opt,name=type,enum=Datum_DatumType" json:"type,omitempty"`
RBool *bool `protobuf:"varint,2,opt,name=r_bool" json:"r_bool,omitempty"`
RNum *float64 `protobuf:"fixed64,3,opt,name=r_num" json:"r_num,omitempty"`
RStr *string `protobuf:"bytes,4,opt,name=r_str" json:"r_str,omitempty"`
RArray []*Datum `protobuf:"bytes,5,rep,name=r_array" json:"r_array,omitempty"`
RObject []*Datum_AssocPair `protobuf:"bytes,6,rep,name=r_object" json:"r_object,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *Datum) Reset() { *m = Datum{} }
func (m *Datum) String() string { return proto.CompactTextString(m) }
func (*Datum) ProtoMessage() {}
func (m *Datum) GetType() Datum_DatumType {
if m != nil && m.Type != nil {
return *m.Type
}
return Datum_R_NULL
}
func (m *Datum) GetRBool() bool {
if m != nil && m.RBool != nil {
return *m.RBool
}
return false
}
func (m *Datum) GetRNum() float64 {
if m != nil && m.RNum != nil {
return *m.RNum
}
return 0
}
func (m *Datum) GetRStr() string {
if m != nil && m.RStr != nil {
return *m.RStr
}
return ""
}
func (m *Datum) GetRArray() []*Datum {
if m != nil {
return m.RArray
}
return nil
}
func (m *Datum) GetRObject() []*Datum_AssocPair {
if m != nil {
return m.RObject
}
return nil
}
type Datum_AssocPair struct {
Key *string `protobuf:"bytes,1,opt,name=key" json:"key,omitempty"`
Val *Datum `protobuf:"bytes,2,opt,name=val" json:"val,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *Datum_AssocPair) Reset() { *m = Datum_AssocPair{} }
func (m *Datum_AssocPair) String() string { return proto.CompactTextString(m) }
func (*Datum_AssocPair) ProtoMessage() {}
func (m *Datum_AssocPair) GetKey() string {
if m != nil && m.Key != nil {
return *m.Key
}
return ""
}
func (m *Datum_AssocPair) GetVal() *Datum {
if m != nil {
return m.Val
}
return nil
}
// A [Term] is either a piece of data (see **Datum** above), or an operator and
// its operands. If you have a [Datum], it's stored in the member [datum]. If
// you have an operator, its positional arguments are stored in [args] and its
// optional arguments are stored in [optargs].
//
// A note about type signatures:
// We use the following notation to denote types:
// arg1_type, arg2_type, argrest_type... -> result_type
// So, for example, if we have a function `avg` that takes any number of
// arguments and averages them, we might write:
// NUMBER... -> NUMBER
// Or if we had a function that took one number modulo another:
// NUMBER, NUMBER -> NUMBER
// Or a function that takes a table and a primary key of any Datum type, then
// retrieves the entry with that primary key:
// Table, DATUM -> OBJECT
// Some arguments must be provided as literal values (and not the results of sub
// terms). These are marked with a `!`.
// Optional arguments are specified within curly braces as argname `:` value
// type (e.x `{noreply:BOOL}`)
// Many RQL operations are polymorphic. For these, alterantive type signatures
// are separated by `|`.
//
// The RQL type hierarchy is as follows:
// Top
// DATUM
// NULL
// BOOL
// NUMBER
// STRING
// OBJECT
// SingleSelection
// ARRAY
// Sequence
// ARRAY
// Stream
// StreamSelection
// Table
// Database
// Function
// Ordering - used only by ORDER_BY
// Pathspec -- an object, string, or array that specifies a path
// Error
type Term struct {
Type *Term_TermType `protobuf:"varint,1,opt,name=type,enum=Term_TermType" json:"type,omitempty"`
// This is only used when type is DATUM.
Datum *Datum `protobuf:"bytes,2,opt,name=datum" json:"datum,omitempty"`
Args []*Term `protobuf:"bytes,3,rep,name=args" json:"args,omitempty"`
Optargs []*Term_AssocPair `protobuf:"bytes,4,rep,name=optargs" json:"optargs,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *Term) Reset() { *m = Term{} }
func (m *Term) String() string { return proto.CompactTextString(m) }
func (*Term) ProtoMessage() {}
func (m *Term) GetType() Term_TermType {
if m != nil && m.Type != nil {
return *m.Type
}
return Term_DATUM
}
func (m *Term) GetDatum() *Datum {
if m != nil {
return m.Datum
}
return nil
}
func (m *Term) GetArgs() []*Term {
if m != nil {
return m.Args
}
return nil
}
func (m *Term) GetOptargs() []*Term_AssocPair {
if m != nil {
return m.Optargs
}
return nil
}
type Term_AssocPair struct {
Key *string `protobuf:"bytes,1,opt,name=key" json:"key,omitempty"`
Val *Term `protobuf:"bytes,2,opt,name=val" json:"val,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *Term_AssocPair) Reset() { *m = Term_AssocPair{} }
func (m *Term_AssocPair) String() string { return proto.CompactTextString(m) }
func (*Term_AssocPair) ProtoMessage() {}
func (m *Term_AssocPair) GetKey() string {
if m != nil && m.Key != nil {
return *m.Key
}
return ""
}
func (m *Term_AssocPair) GetVal() *Term {
if m != nil {
return m.Val
}
return nil
}
func init() {
proto.RegisterEnum("VersionDummy_Version", VersionDummy_Version_name, VersionDummy_Version_value)
proto.RegisterEnum("VersionDummy_Protocol", VersionDummy_Protocol_name, VersionDummy_Protocol_value)
proto.RegisterEnum("Query_QueryType", Query_QueryType_name, Query_QueryType_value)
proto.RegisterEnum("Frame_FrameType", Frame_FrameType_name, Frame_FrameType_value)
proto.RegisterEnum("Response_ResponseType", Response_ResponseType_name, Response_ResponseType_value)
proto.RegisterEnum("Response_ErrorType", Response_ErrorType_name, Response_ErrorType_value)
proto.RegisterEnum("Response_ResponseNote", Response_ResponseNote_name, Response_ResponseNote_value)
proto.RegisterEnum("Datum_DatumType", Datum_DatumType_name, Datum_DatumType_value)
proto.RegisterEnum("Term_TermType", Term_TermType_name, Term_TermType_value)
}
Reference in New Issue View Git Blame Copy Permalink