package fit.columnar
Get desktop application:
View/edit binary Protocol Buffers messages
To better permit DRY, instance.executeQuery() and scope.executeQuery() are here rather than in their respective services.
message
columnar.query.proto:347AsyncCancelHandleRequest ================== Calls the cancel function on the QueryHandle returned from startQuery().
string query_handle = 1
message
columnar.query.proto:374AsyncDiscardResultsRequest ================== Calls the discard function on the QueryResultHandle.
string query_handle = 1
message
columnar.query.proto:362Some modes of some SDKs will not have a QueryResult, in which case this should be surfaced in the performer caps, and the driver should not be sending it.
string query_handle = 1
optional options = 2
RPCs pertaining to server async query execution via StartQuery()
message
columnar.query.proto:315AsyncFetchStatusRequest ================== The driver is requesting the SDK call the FetchStatus request on QueryHandle. The performer should block until this (or failure) has been returned from that call. The performer must hold onto the QueryStatus object keyed by the query_handle, regardless of ResultsReady().
string query_handle = 1
message
columnar.query.proto:319oneof result
query_status = 1
failure = 2
message
columnar.query.proto:340AsyncQueryStatusResultHandleRequest ================== Calls ResultHandle() on the QueryStatus returned from the latest AsyncFetchStatus call. The driver may call this when ResultsReady() was false, to test error handling. If the driver calls this before an AsyncFetchStatus call, this can be treated as a driver bug. On success, the performer stores the SDK's QueryResultHandle internally, keyed by query_handle.
string query_handle = 1
message
columnar.query.proto:269Same as CloseQueryResultRequest except for all query_handles.
(message has no fields)
message
columnar.query.proto:264CloseQueryResultRequest ======================= Executes nothing on the SDK, and is purely for cleanup purposes. Tells the performer a query_handle is no longer needed. The performer should not cancel anything as a result of this call, or block until row iteration or metadata is complete, or similar. It may only do memory cleanup, remove the query_handle from internal collections, and do similar "tidyup". This should clean up ALL state associated with the query_handle, regardless of whether it originated from executeQuery() or startQuery(). For startQuery() handles, this includes any stored QueryHandle, QueryStatus, QueryResultHandle, and QueryResult.
string query_handle = 1
message
columnar.query.proto:46ExecuteQueryRequest ================== Tells the performer it should **asynchronously** call [instance|scope].executeQuery(), immediately after it returns the ExecuteQueryResponse. To stress: the performer returns an ExecuteQueryResponse immediately, and *then* starts executing executeQuery(), in the background. So no failures from executeQuery() can be reflected in the ExecuteQueryResponse. The driver may use QueryResultRequest to check the executeQuery() result later. Asynchronicity and query_handle ------------------------------- Though not every platform has equally strong support for it, we need queries to be executed asynchronously. This is partly to allow cancelling queries at any time, given that cancellation is a key part of the Columnar PRD. So the performer will execute the query asynchronously. An SDK that is natively SDK-async will have no issue with this. An SDK-sync SDK on the other hand, will need to execute the blocking executeQuery() call in a background thread/coroutine/fibre etc. Either way, the performer holds on to any failures and results until they are requested by the driver. It associates that call and all such resources tied to it with a "query_handle" that it creates and returns in the ExecuteQueryResponse. The driver will subsequently use this handle to ask the performer to iterate, cancel, etc. The ONLY time this query_handle and its resources get destroyed, is on a CloseQueryResultRequest. The performer should not e.g. automatically discard cancellation tokens or other resources just because iteration is complete, as we want to be able to test user errors. Note the performer should never buffer more than 1 row, as we need to test slow consumers and backpressure. See QueryRowRequest for more details.
oneof level
cluster_level = 1
scope_level = 2
string statement = 3
optional options = 4
optional content_as = 5
This will be used anytime the performer processes a row. It should be used for queryResult.rowsAs<T>(), or row.contentAs<T>(), or whatever is most idiomatic for the SDK. It will be sent following these rules if performer declares support for: ROW_DESERIALIZATION_STATIC_ROW_TYPING - always sent (as row streaming is only possible if a <T> is set). ROW_DESERIALIZATION_DYNAMIC_ROW_TYPING - not sent (as the Deserializer controls how the content is output). ROW_DESERIALIZATION_STATIC_ROW_TYPING_INDIVIDUAL - not sent (the equivalent field on the QueryRowRequest will be used instead).
bool require_cancellation = 6
The driver may cancel this operation, and it could be at any time before or during both the executeQuery call and the row streaming. The performer should prepare for this as needed for the SDK. For instance, if cancellation is done with a cancellation token, the performer should create it here.
message
columnar.query.proto:90string query_handle = 1
optional metadata = 2
message
columnar.query.proto:141QueryCancelRequest ================== The driver is emulating the user cancelling the operation. The performer should make no assumptions on if, when or how often the driver will call this. The intent is that the performer cancels whatever is happening, in the SDK-idiomatic way. That could be during the initial executeQuery(), or the subsequent row iteration, or potentially while fetching the metadata - or at any point before, between or after those operations. So the performer may end up using a range of cancellation methods depending on what phase in the query this request arrives. It is intentionally left up to the performer to decide how to interpret cancellation in each phase, as it is idiomatic for each SDK. But per the RFC - it is mandatory that cancellation be possible, in each phase. Edge cases ---------- To clarify some edge cases - if the cancellation arrives: 1. Before the performer has asynchronously started executeQuery(): the performer blocks until it has, and then cancels. 2. After the operation is completed and metadata has been fetched: if there is something to cancel (such as a cancellation token) then the SDK cancels it. Otherwise it is a no-op. (Remember that all resources associated with a given query_handle should be cleaned up ONLY in a CloseQueryResult). The performer should not discard the query_handle or associated resources after cancellation, to allow testing user error such as double-cancellation. Error handling -------------- There is no QueryCancelResponse, as per the RFC, cancellation is a fire-and-forget operation that should not fail. If it does fail (perhaps for some platform-specific reason or when testing an edge case like a user cancellation an operation twice), the error should be reported in the EmptyResultOrFailureResponse. Note this error is that reported by the cancellation itself, e.g. the `cancellationToken.cancel()` or the `queryResult.cancel()` or the `queryPromise.cancel()`, as idiomatic. It is NOT the result of the `executeQuery` call or any ongoing row iteration - those are fetched by the driver separately.
string query_handle = 1
message
columnar.query.proto:223QueryMetadataRequest ==================== Equivalent to `queryResult.metadata()`. The performer should make no assumptions on if, when or how often the driver will call this, and it should not discard the query_handle and any associated resources after it is called (instead wait for CloseQueryResult). As always, the performer should model the returned QueryResultMetadataResponse based purely on the SDK's behaviour, and provide no interpretation of its own. If called by the driver before row iteration is complete then, per RFC, the SDK is expected to fast-fail. If for some reason it does not, and it blocks until metadata is available - the performer should follow suit, and not try to provide the correct behaviour to satisfy the tests.
string query_handle = 1
message
columnar.query.proto:227oneof result
success = 1
failure = 2
optional metadata = 3
Get the QueryResult from the executeQuery()
message
columnar.query.proto:102QueryResultRequest ================== The driver is requesting the `QueryResult` returned from the asynchronously-executing executeQuery(). The performer should block until this (or failure) has been returned from that call. Some modes of some SDKs will not have a QueryResult, in which case this should be surfaced in the performer caps, and the driver should not be sending it.
string query_handle = 1
rpc QueryRow (, )
columnar.services.proto:40message
columnar.query.proto:170QueryRowRequest =============== The driver is emulating the user iterating through one row. It is essential that we have the ability to test slow consumers and their effect on backpressure, so the performer must not introduce any buffering of its own, and must ask for or wait for exactly one row from the SDK on each QueryRowRequest. Specifically: In a pull-based model --------------------- The performer simulates the user calling `rowIterator.next()`, or similar. If the only way to iterate rows is `for async (row in rows)` or similar, then the performer will need to block inside the for-loop repeatedly, only allowing the next row to be fetched as a QueryRowRequest comes in from the driver. In a push-based model --------------------- The performer should wait for the SDK to send the next row (and only the next row), if one hasn't been sent already. In practice this is likely to be done with a concurrent queue that can contain a maximum of exactly 1 element, and having the row callback (or equivalent) block if this queue is full. Remember - though push-based, we need to simulate the user not keeping up with the rows, e.g. taking too long inside the callback. The performer should make no assumptions on if, when or how often the driver will call this, and it should not discard the query_handle or associated resources after all rows are completed to allow testing user errors.
string query_handle = 1
optional content_as = 2
This can be sent iff performer declares support for ROW_DESERIALIZATION_STATIC_ROW_TYPING_INDIVIDUAL. If sent then the performer needs to deserialize the next row accordingly.
message
columnar.query.proto:178oneof result
success = 1
row_level_failure = 2
If row iteration fails, raise it here.
execute_query_failure = 3
The executeQuery() call failed while we were waiting for a row. Only used by push-based models that don't separate QueryResult from row iteration. Most performers should not set this.
optional metadata = 4
rpc StartQuery (, )
columnar.services.proto:36message
columnar.query.proto:279StartQueryRequest ================== Tells the performer it should **synchronously** call [instance|scope].startQuery(). Unlike ExecuteQueryRequest, this is a synchronous call that should return only once startQuery() has returned, and it should return a UUID representing the query_handle from that call. All subsequent calls from the driver that reference that query_handle.
oneof level
cluster_level = 1
scope_level = 2
string statement = 3
optional options = 4
message
columnar.query.proto:303oneof result
string query_handle = 1
failure = 2
All RPCs related to the Columnar SDK.
The performer should close all Columnar Cluster objects it has open. In the RFC this is `cluster.close()`.
optional execution_context = 1
The performer should close a previously-opened Columnar Cluster instance. In the RFC this is `cluster.close()`. It can safely assume that if that instance does not exist, then this is a driver bug - it does not have to handle this.
optional execution_context = 1
Columnar Cluster resource management.
Requests the performer use the SDK to create a connection to a Columnar cluster.
string cluster_connection_id = 1
The id to use for this connection.
string connection_string = 2
Details of the cluster connection. As with all fields (see rule 1 in README.md), the performer should pass all fields directly to the SDK without manipulation. E.g. it should not prepend couchbase:// to cluster_connection_string or similar.
optional credential = 3
optional options = 4
map<string, string> tunables = 5
Can apply SDK tunables that can't be represented generically in GRPC. One example is for performance testing, where we may want to experiment with various approaches in say the Java SDK. So one run may send "com.couchbase.executorMaxThreadCount"="10", and the next set it to "20". Interpretation of the tunables, and how to apply them inside the SDK, is completely SDK-dependent. The intent is that the tunables be associated with the cluster connection. Generally performers can ignore this field unless they are explicitly planning on using it.
optional execution_context = 6
rpc Echo (, )
columnar.services.proto:21Performer management.
message
columnar.caps.proto:186(message has no fields)
message
columnar.caps.proto:212SDK sdk = 1
string sdk_version = 2
Identifies the version of the Columnar SDK. For example, "1.1.2".
map<int32, > cluster_new_instance = 3
ColumnarService.ClusterNewInstance and everything that exists at time of commit under those messages.
map<int32, > cluster_close = 4
ColumnarService.ClusterClose and ColumnarService.CloseAllClusters, and everything that exists at time of commit under those messages.
map<int32, > cluster_execute_query = 5
ColumnarCrossService.ExecuteQuery and everything that exists at time of commit under those messages, for instance.executeQuery().
map<int32, > scope_execute_query = 6
ColumnarCrossService.ExecuteQuery and everything that exists at time of commit under those messages, for scope.executeQuery().
map<int32, > sdk_connection_error = 7
AnalyticsProduct analytics_product = 8
bool supports_server_async_queries = 9
WWhether the SDK supports async queries, that is startQuery.
optional credential_support = 10
Updates the credential on a previously-created cluster connection. Maps to the EA RFC's `cluster.credential(newCredential)`.
Requests the performer to update the credential on an existing cluster connection.
optional execution_context = 1
optional credential = 2
Used in:
COLUMNAR = 0
The SDKs for Capella Columnar
ANALYTICS = 1
The SDKs for Enterprise Analytics and (in future) Capella Analytics
message
columnar.query.proto:363Used in:
optional deserializer = 1
message
columnar.query.proto:320Used in:
bool results_ready = 1
The result of calling ResultsReady() on the QueryStatus.
string to_string = 2
The string representation of the QueryStatus (e.g. via toString()).
Used in: ,
oneof type
username_and_password = 1
jwt_auth = 2
certificate_auth = 3
Authenticates using a client certificate (mTLS). The SDK authenticates the client during the TLS handshake.
Used in:
string cert = 1
PEM-encoded X509 client certificate
string key = 2
PEM-encoded private key
Authenticates using a JSON Web Token (JWT). The SDK sets an "Authorization: Bearer <jwt>" header on every HTTP request.
Used in:
string jwt = 1
Used in:
string username = 1
string password = 2
Used in:
optional deserializer = 1
optional security = 2
optional timeout = 3
optional int32 max_retries = 4
Used in:
optional bool trust_only_capella = 1
optional string trust_only_pem_string = 3
trustOnlyPemFile is not exposed, as it will not work well with Docker-based FIT
optional bool trust_only_platform = 4
optional bool disable_server_certificate_verification = 5
repeated string cipher_suites = 6
Used in:
optional connect_timeout = 1
optional dispatch_timeout = 2
optional query_timeout = 3
optional handle_timeout = 4
message
columnar.errors.proto:10An exception derived from ColumnarError
Used in:
optional cause = 1
optional sub_exception = 2
If the ColumnarError is a specific subclass exception, include the specific error. If not provided then this is to be a generic ColumnarError
string as_string = 3
Broadly this is the result of outputting the exception - what the user would see if they wrote it into their logs. E.g. for Java `ex.toString()`, for C++ `std::cout << err`. It is expected to contain the error context, per the RFC.
message
columnar.serialization.proto:65ContentAs ========= Where the SDK supports a rowsAs<T> or row.contentAs<T> or similar - this controls the user setting the `T`. It's only sent to performers that declare support for ROW_DESERIALIZATION_STATIC_ROW_TYPING or ROW_DESERIALIZATION_STATIC_ROW_TYPING_INDIVIDUAL. For ROW_DESERIALIZATION_DYNAMIC_ROW_TYPING performers/SDKs, T doesn't exist, and the output type is decided purely by the Deserializer.
Used in: ,
oneof as
bool as_byte_array = 1
T = byte[] Intended to get the result as a byte array, and return that directly. The result is returned in ContentTypes.content_was_bytes. Pseudocode for performer: byte[] returnOverGRPC = someResult.contentAs[Array[Byte]]()
bool as_map = 2
T = Map This will usually be used for JSON objects, e.g. the list items can be heterogeneous and can be any of the JSON types, including further lists or maps. The result is returned in ContentTypes.content_was_map. Pseudocode for performer: Map result = row.contentAs<Map>() or queryResult.rowsAs<Map>() byte[] returnOverGRPC = platformDependentMethodToSerializeToJSON(result)
bool as_list = 3
T = List This will usually be used for JSON lists, e.g. the list items can be heterogeneous and can be any of the JSON types, including further lists or maps. The result is returned in ContentTypes.content_was_list. Pseudocode for performer: List result = row.contentAs<List>() or queryResult.rowsAs<List>() byte[] returnOverGRPC = platformDependentMethodToSerializeToJSON(result)
bool as_string = 4
T = String Intended to get the result as string, and return that directly. The result is returned in ContentTypes.content_was_string. Pseudocode for performer: String result = row.contentAs<String>() or queryResult.rowsAs<String>()
message
columnar.serialization.proto:103"ContentWas" because this was the content the performer got from the SDK, before it serialized it up to send back to the driver.
Used in:
oneof content
bytes content_was_bytes = 1
content_was_map = 2
content_was_list = 3
bool content_was_boolean = 4
string content_was_string = 5
double content_was_double = 6
int64 content_was_integer = 7
google.protobuf.NullValue content_was_null = 8
message
columnar.caps.proto:13Used in:
bool supports_jwt_credential = 1
bool supports_certificate_credential = 2
bool supports_set_credential = 3
message
columnar.serialization.proto:11Used in: , ,
oneof type
json = 1
passthrough = 2
Will only be sent if performer declares support for supports_passthrough_deserializer.
custom = 3
Will only be sent if performer declares support for supports_custom_deserializer.
message
columnar.serialization.proto:47* **Custom Deserializer** Uses a custom `Deserializer` implementation with specific serialization and deserialization logic. **Deserialization Logic:** ```java public <T> T deserialize(Class<T> target, byte[] input) { // Parse the byte array into a JSON object JsonObject jsonObject = parseByteArrayToJsonObject(input); // Upsert the "Serialized" field to false, "Serialized" key may or may not present while deserializing. jsonObject.put("Serialized", false); // Convert the JSON object back to the target type and return return convertJsonObjectToTargetType(jsonObject, target); } ``` **Implementation Details:** - **`parseByteArrayToJsonObject(byte[] input)`**: - Deserializes the byte array into a `JsonObject`. - **`convertJsonObjectToTargetType(JsonObject jsonObject, Class<T> target)`**: - Converts the `JsonObject` to the specified target type `T`. **Notes for Performers:** - Implementations in other languages should follow the same logical steps using equivalent constructs. - Proper error handling should be included to manage deserialization exceptions. - This deserializer assumes that the row is a JSON object. If the byte array cannot be parsed into a JSON object, then the deserializer should return/raise an error.
Used in:
(message has no fields)
message
columnar.serialization.proto:12Used in:
(message has no fields)
message
columnar.serialization.proto:14Used in:
(message has no fields)
message
columnar.result.proto:13Used as response type in: ColumnarCrossService.AsyncCancelHandle, ColumnarCrossService.AsyncDiscardResults, ColumnarCrossService.AsyncFetchResults, ColumnarCrossService.AsyncQueryStatusResultHandle, ColumnarCrossService.CloseAllQueryResults, ColumnarCrossService.CloseQueryResult, ColumnarCrossService.QueryCancel, ColumnarCrossService.QueryResult, ColumnarService.CloseAllClusters, ColumnarService.ClusterClose, ColumnarService.ClusterNewInstance, ColumnarService.SetCredential
oneof result
bool empty_success = 1
error = 2
optional metadata = 3
message
columnar.errors.proto:73Used in: , , , , ,
oneof error
columnar = 1
platform = 2
message
columnar.query.proto:47Used in:
optional bool priority = 2
The priority option is NOT in the Analytics SDKs, its only in the Columnar SDKs
optional parameters_positional = 3
A google.protobuf.ListValue is essentially a JSON array
optional parameters_named = 4
A google.protobuf.Struct is essentially a JSON object
optional bool readonly = 5
optional Options.ScanConsistency scan_consistency = 6
optional raw = 7
optional timeout = 8
optional deserializer = 9
optional int32 max_retries = 10
Used in:
SCAN_CONSISTENCY_NOT_BOUNDED = 0
SCAN_CONSISTENCY_REQUEST_PLUS = 1
Some metadata and config on how the SDK should execute the request and return responses.
Used in: , , ,
int32 mode_index = 1
Which mode the SDK should run in. See `FetchPerformerCapsResponse` for an explanation.
For operations that exist at a Cluster object level.
Used in: , , ,
optional shared = 1
string cluster_id = 2
A previously-created Cluster. The performer can assume that if this Cluster does not exist then that is a FIT driver bug, and does not need to handle this case.
For operations that exist at a Scope object level.
Used in: ,
optional shared = 1
string cluster_id = 2
A previously-created Cluster. The performer can assume that if this Cluster does not exist then that is a FIT driver bug, and does not need to handle this case.
string database_name = 3
string scope_name = 4
message
columnar.errors.proto:54Used to represent the detailed InvalidCredentialException sub-ColumnarError type
No additional info here yet
Used in:
(message has no fields)
message
columnar.caps.proto:24Currently empty.
Used in:
(message has no fields)
message
columnar.caps.proto:19Used in:
bool supports_dispatch_timeout = 1
The SDK implements a dispatch timeout, which is optional. The SDK may or may not implement this feature.
message
columnar.caps.proto:29How the SDK exposes executeQuery().
Used in:
PerApiElementExecuteQuery.ExecuteQueryReturns execute_query_returns = 1
PerApiElementExecuteQuery.RowIteration row_iteration = 2
PerApiElementExecuteQuery.RowDeserialization row_deserialization = 3
bool supports_passthrough_deserializer = 4
If the SDK includes the PassthroughDeserializer. This is likely to go hand-in-hand with ROW_DESERIALIZATION_DYNAMIC_ROW_TYPING.
bool supports_custom_deserializer = 5
Covers whether the SDK follows the "standard" model of an initial `executeQuery()` call returning a `QueryResult` that can then be iterated through.
Used in:
EXECUTE_QUERY_RETURNS_UNSPECIFIED = 0
Should never be sent. Included as a standard protobuf best practice.
EXECUTE_QUERY_RETURNS_QUERY_RESULT = 1
An SDK that has a "standard" model something like the following: `QueryResult result = executeQuery(...)` `PromiseLike<QueryResult> result = executeQuery(...)`
EXECUTE_QUERY_RETURNS_QUERY_METADATA = 2
An SDK that looks something like the following (likely just used by push-based SDKs): `QueryMetadata metadata = executeQuery(...)`
Covers how/if SDKs allow users to convert rows directly into specific types.
Used in:
ROW_DESERIALIZATION_UNSPECIFIED = 0
Should never be sent. Included as a standard protobuf best practice.
ROW_DESERIALIZATION_STATIC_ROW_TYPING = 1
If the user can specify that rows be converted into a particular type, but only for all rows. Something like: `Iterator<UserDAO> users = queryResult.rowsAs<UserDAO>()` or `executeQuery<UserDAO>("SELECT", (row: UserDAO) => {})`
ROW_DESERIALIZATION_STATIC_ROW_TYPING_INDIVIDUAL = 2
If the user can specify that rows be converted into a particular type, and can specify a different type for each row. Something like: ``` const rows = queryResult.rows() for (const row in rows) { row.contentAs<UserDAO>() } ``` or ``` executeQuery("SELECT", row => row.contentAs<UserDAO>())` ```
ROW_DESERIALIZATION_DYNAMIC_ROW_TYPING = 3
If rows are generally exposed however the Deserializer exposes them, with the type being decided dynamically by the Deserializer. Something like: ``` const queryResult = await executeQuery("SELECT") const rows = queryResult.rows() for await (const row of rows) { // with default Deserializer row is probably a platform-native object, like a JS object here in Node } ``` or with a custom Deserializer ``` const queryResult = await executeQuery("SELECT", queryOptions().deserializer(UserDAODeserializer)) const rows = queryResult.rows() for (const row in rows) { // row is of type UserDAO } ```
Covers how a user allows users to stream and iterate rows.
Used in:
ROW_ITERATION_UNSPECIFIED = 0
Should never be sent. Included as a standard protobuf best practice.
ROW_ITERATION_STREAMING_ITERATOR_BASED = 1
If row iteration in this SDK mode looks something like (it might be a Stream or similar rather than an Iterator): ``` var iterator = queryResult.rowsAs<SomeContent>() while (iterator.hasNext()) { SomeContent row = iterator.next() } ``` or ``` var iterator = queryResult.rowsAs() while (iterator.hasNext()) { var row = iterator.next() } ```
ROW_ITERATION_STREAMING_PUSH_BASED = 2
If row iteration in this SDK mode looks something like: ``` executeQuery("SELECT...", (row) => { }) ```
ROW_ITERATION_BUFFERED = 3
All Columnar SDKs should be streaming-centric, but some may have optional modes that are fully buffered. If row iteration in this SDK mode looks something like: `List<SomeContent> rows = queryResult.rowsAs<SomeContent>()` or `List rows = queryResult.rows()` The important distinction is that the rows are fully buffered by the SDK already, by the point `executeQuery` returns.
message
columnar.caps.proto:9Currently empty.
(message has no fields)
message
columnar.errors.proto:34Used to represent any error that does not derive from ColumnarException/ColumnarError
Used in:
PlatformErrorType type = 1
string as_string = 2
Broadly this is the result of outputting the exception - what the user would see if they wrote it into their logs. E.g. for Java `ex.toString()`.
Used in:
PLATFORM_ERROR_UNSPECIFIED = 0
Should never be sent and performers do not need to handle it. Included as a standard protobuf best practice.
PLATFORM_ERROR_OTHER = 1
If it does not fall into one of the other, better categories below.
PLATFORM_ERROR_INVALID_ARGUMENT = 2
PLATFORM_ERROR_FEATURE_NOT_AVAILABLE = 3
message
columnar.errors.proto:43Used to represent the detailed QueryException sub-ColumnarError type
Used in:
int32 error_code = 1
string server_message = 2
message
columnar.errors.proto:59Used to represent the detailed QueryNotFoundException sub-ColumnarError type
No additional info here yet
Used in:
(message has no fields)
message
columnar.query.proto:228Used in:
string request_id = 1
repeated warnings = 2
optional metrics = 3
message
columnar.query.proto:229Used in:
optional elapsed_time = 1
optional execution_time = 2
uint64 result_count = 3
uint64 result_size = 4
uint64 processed_objects = 5
message
columnar.query.proto:237Used in:
uint32 code = 1
string message = 2
message
columnar.query.proto:184Used in:
optional row = 1
A single row. It will usually be present, but is allowed to be optional to handle some niche cases, such as the end_of_stream going-beyond-the-last-row case, below.
bool end_of_stream = 2
`end_of_stream` is intended to emulate the user idiomatically discovering that there are no more rows. The "for loop" ends, the it.hasNext() returns false, the push-based ExecuteQuery returns - this sort of concept. It is allowed to return true either with the final row, or on the next row (in which csae the `row` field will be left empty). Use whichever is most idiomatic for the SDK.
message
columnar.query.proto:179Used in:
optional row_content = 1
Present iff the driver requested deserialization via sending content_as.
message
columnar.metadata.proto:12Metadata that all responses will need.
Allows the performer to report how long an operation took.
Used in: , , ,
int64 elapsed_nanos = 1
Clocks are hard. Many OS/platform combinations cannot guarantee nanosecond level precision of a wallclock time, but can provide such precision for elapsed time. `elapsedNanos` is intended to be, as precisely as the platform can measure it, the exact time taken by the operation in nanoseconds. There is rarely JSON processing in Columnar, and performance requirements in general are looser, so unlike Classic performers do not need to start this time just before the operation is sent into the SDK (e.g. after any JSON processing and/or options handling). They are free to start it at any reasonable point between the RPC beginning and the SDK call being made, and end is soon after the SDk call ends. This should ease performer implementation. `initiated` is a wallclock time, used to place this operation into a one second bucket. This should be as accurate as the platform can provide (often realistically this is only accurate to 10 millis or so). For failed operations: `initiated` needs to be the wallclock time the operation was initiated, not when it failed which can be potentially X seconds later. `elapsed_nanos` should be the time elapsed between `initiated` and the exception being raised.
optional initiated = 2
Should never be sent. Included as a standard protobuf best practice.
Used in:
SDK_UNSPECIFIED = 0
SDK_JAVA = 1
SDK_PYTHON = 2
SDK_GO = 3
SDK_PHP = 4
SDK_RUBY = 5
SDK_NET = 6
SDK_NODE = 7
SDK_SCALA = 8
SDK_KOTLIN = 9
SDK_CXX = 10
message
columnar.caps.proto:143Used in:
SdkConnectionError.InvalidCredentialErrorType invalid_cred_error_type = 1
The type of error sdk returns if cluster connection fails when user passes wrong username or password.
SdkConnectionError.BootstrapErrorType bootstrap_error_type = 2
Enum to specify the type of bootstrap error.
Used in:
UNSPECIFIED_BOOTSTRAP_ERROR = 0
Should never be sent. Included as a standard protobuf best practice.
ERROR_AS_TIMEOUT_EXCEPTION = 1
The SDK returns error type for COLUMNAR_TIMEOUT_EXCEPTION, when a connection attempt fails after the minimum of the three timeout expires ie connect, dispatch and query
AS_COLUMNAR_ERROR = 2
The SDK returns an error of type COLUMNAR_ERROR when a connection attempt fast fails without any sub exception like timeout.
OTHER_BOOTSTRAP_ERROR = 3
The SDK returns a error of some other type of topology tracking error when a connection attempt fails.
UNKNOWN_BOOTSTRAP_ERROR_EXCEPTION = 4
The SDK returns a error which driver can't understand
Enum to specify the type of invalid credential error.
Used in:
UNSPECIFIED_CREDENTIAL_ERROR = 0
Should never be sent. Included as a standard protobuf best practice.
AS_INVALID_CREDENTIAL_EXCEPTION = 1
The SDK returns an error of type INVALID_CREDENTIAL_EXCEPTION when a connection attempt fails due to incorrect username or password.
AS_TIMEOUT_EXCEPTION = 2
The SDK returns error type for COLUMNAR_TIMEOUT_EXCEPTION, when a connection attempt fails after the minimum of the three timeout expires ie connect, dispatch and query
UNKNOWN_CREDENTIAL_ERROR_EXCEPTION = 3
The SDK returns a error which driver can't understand
message
columnar.query.proto:280Used in:
optional parameters_positional = 2
optional parameters_named = 3
optional bool readonly = 4
optional Options.ScanConsistency scan_consistency = 5
optional raw = 6
optional timeout = 7
optional int32 max_retries = 8
Used in:
SCAN_CONSISTENCY_NOT_BOUNDED = 0
SCAN_CONSISTENCY_REQUEST_PLUS = 1
message
columnar.errors.proto:64Represents the ColumnarError's sub types
Used in:
oneof sub_error
query_exception = 1
timeout_exception = 2
invalid_credential_exception = 3
query_not_found_exception = 4
message
columnar.errors.proto:49Used to represent the detailed TimeoutException sub-ColumnarError type
No additional info here yet
Used in:
(message has no fields)