googleapis
Version:
Google APIs Client Library for Node.js
1,208 lines • 123 kB
TypeScript
/**
* Copyright 2015 Google Inc. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
import { AxiosPromise } from 'axios';
import { GoogleApis } from '../..';
import { BodyResponseCallback, GlobalOptions, MethodOptions } from '../../lib/api';
/**
* Cloud Spanner API
*
* Cloud Spanner is a managed, mission-critical, globally consistent and
* scalable relational database service.
*
* @example
* const google = require('googleapis');
* const spanner = google.spanner('v1');
*
* @namespace spanner
* @type {Function}
* @version v1
* @variation v1
* @param {object=} options Options for Spanner
*/
export declare class Spanner {
_options: GlobalOptions;
google: GoogleApis;
root: this;
projects: Resource$Projects;
constructor(options: GlobalOptions, google: GoogleApis);
getRoot(): this;
}
/**
* The request for BeginTransaction.
*/
export interface Schema$BeginTransactionRequest {
/**
* Required. Options for the new transaction.
*/
options: Schema$TransactionOptions;
}
/**
* Associates `members` with a `role`.
*/
export interface Schema$Binding {
/**
* Specifies the identities requesting access for a Cloud Platform resource.
* `members` can have the following values: * `allUsers`: A special
* identifier that represents anyone who is on the internet; with or
* without a Google account. * `allAuthenticatedUsers`: A special identifier
* that represents anyone who is authenticated with a Google account or a
* service account. * `user:{emailid}`: An email address that represents a
* specific Google account. For example, `alice@gmail.com` or
* `joe@example.com`. * `serviceAccount:{emailid}`: An email address that
* represents a service account. For example,
* `my-other-app@appspot.gserviceaccount.com`. * `group:{emailid}`: An email
* address that represents a Google group. For example,
* `admins@example.com`. * `domain:{domain}`: A Google Apps domain name that
* represents all the users of that domain. For example, `google.com` or
* `example.com`.
*/
members: string[];
/**
* Role that is assigned to `members`. For example, `roles/viewer`,
* `roles/editor`, or `roles/owner`. Required
*/
role: string;
}
/**
* Metadata associated with a parent-child relationship appearing in a PlanNode.
*/
export interface Schema$ChildLink {
/**
* The node to which the link points.
*/
childIndex: number;
/**
* The type of the link. For example, in Hash Joins this could be used to
* distinguish between the build child and the probe child, or in the case of
* the child being an output variable, to represent the tag associated with
* the output variable.
*/
type: string;
/**
* Only present if the child node is SCALAR and corresponds to an output
* variable of the parent node. The field carries the name of the output
* variable. For example, a `TableScan` operator that reads rows from a table
* will have child links to the `SCALAR` nodes representing the output
* variables created for each column that is read by the operator. The
* corresponding `variable` fields will be set to the variable names assigned
* to the columns.
*/
variable: string;
}
/**
* The request for Commit.
*/
export interface Schema$CommitRequest {
/**
* The mutations to be executed when this transaction commits. All mutations
* are applied atomically, in the order they appear in this list.
*/
mutations: Schema$Mutation[];
/**
* Execute mutations in a temporary transaction. Note that unlike commit of a
* previously-started transaction, commit with a temporary transaction is
* non-idempotent. That is, if the `CommitRequest` is sent to Cloud Spanner
* more than once (for instance, due to retries in the application, or in the
* transport library), it is possible that the mutations are executed more
* than once. If this is undesirable, use BeginTransaction and Commit instead.
*/
singleUseTransaction: Schema$TransactionOptions;
/**
* Commit a previously-started transaction.
*/
transactionId: string;
}
/**
* The response for Commit.
*/
export interface Schema$CommitResponse {
/**
* The Cloud Spanner timestamp at which the transaction committed.
*/
commitTimestamp: string;
}
/**
* Metadata type for the operation returned by CreateDatabase.
*/
export interface Schema$CreateDatabaseMetadata {
/**
* The database being created.
*/
database: string;
}
/**
* The request for CreateDatabase.
*/
export interface Schema$CreateDatabaseRequest {
/**
* Required. A `CREATE DATABASE` statement, which specifies the ID of the new
* database. The database ID must conform to the regular expression
* `a-z*[a-z0-9]` and be between 2 and 30 characters in length. If the
* database ID is a reserved word or if it contains a hyphen, the database ID
* must be enclosed in backticks (`` ` ``).
*/
createStatement: string;
/**
* An optional list of DDL statements to run inside the newly created
* database. Statements can create tables, indexes, etc. These statements
* execute atomically with the creation of the database: if there is an error
* in any statement, the database is not created.
*/
extraStatements: string[];
}
/**
* Metadata type for the operation returned by CreateInstance.
*/
export interface Schema$CreateInstanceMetadata {
/**
* The time at which this operation was cancelled. If set, this operation is
* in the process of undoing itself (which is guaranteed to succeed) and
* cannot be cancelled again.
*/
cancelTime: string;
/**
* The time at which this operation failed or was completed successfully.
*/
endTime: string;
/**
* The instance being created.
*/
instance: Schema$Instance;
/**
* The time at which the CreateInstance request was received.
*/
startTime: string;
}
/**
* The request for CreateInstance.
*/
export interface Schema$CreateInstanceRequest {
/**
* Required. The instance to create. The name may be omitted, but if
* specified must be `<parent>/instances/<instance_id>`.
*/
instance: Schema$Instance;
/**
* Required. The ID of the instance to create. Valid identifiers are of the
* form `a-z*[a-z0-9]` and must be between 6 and 30 characters in length.
*/
instanceId: string;
}
/**
* The request for CreateSession.
*/
export interface Schema$CreateSessionRequest {
/**
* The session to create.
*/
session: Schema$Session;
}
/**
* A Cloud Spanner database.
*/
export interface Schema$Database {
/**
* Required. The name of the database. Values are of the form
* `projects/<project>/instances/<instance>/databases/<database>`,
* where `<database>` is as specified in the `CREATE DATABASE`
* statement. This name can be passed to other API methods to identify the
* database.
*/
name: string;
/**
* Output only. The current database state.
*/
state: string;
}
/**
* Arguments to delete operations.
*/
export interface Schema$Delete {
/**
* Required. The primary keys of the rows within table to delete. Delete is
* idempotent. The transaction will succeed even if some or all rows do not
* exist.
*/
keySet: Schema$KeySet;
/**
* Required. The table whose rows will be deleted.
*/
table: string;
}
/**
* A generic empty message that you can re-use to avoid defining duplicated
* empty messages in your APIs. A typical example is to use it as the request or
* the response type of an API method. For instance: service Foo { rpc
* Bar(google.protobuf.Empty) returns (google.protobuf.Empty); } The JSON
* representation for `Empty` is empty JSON object `{}`.
*/
export interface Schema$Empty {
}
/**
* The request for ExecuteSql and ExecuteStreamingSql.
*/
export interface Schema$ExecuteSqlRequest {
/**
* The SQL query string can contain parameter placeholders. A parameter
* placeholder consists of `'@'` followed by the parameter name.
* Parameter names consist of any combination of letters, numbers, and
* underscores. Parameters can appear anywhere that a literal value is
* expected. The same parameter name can be used more than once, for example:
* `"WHERE id > @msg_id AND id < @msg_id + 100"` It is an
* error to execute an SQL query with unbound parameters. Parameter values
* are specified using `params`, which is a JSON object whose keys are
* parameter names, and whose values are the corresponding parameter values.
*/
params: any;
/**
* It is not always possible for Cloud Spanner to infer the right SQL type
* from a JSON value. For example, values of type `BYTES` and values of type
* `STRING` both appear in params as JSON strings. In these cases,
* `param_types` can be used to specify the exact SQL type for some or all of
* the SQL query parameters. See the definition of Type for more information
* about SQL types.
*/
paramTypes: any;
/**
* If present, results will be restricted to the specified partition
* previously created using PartitionQuery(). There must be an exact match
* for the values of fields common to this message and the
* PartitionQueryRequest message used to create this partition_token.
*/
partitionToken: string;
/**
* Used to control the amount of debugging information returned in
* ResultSetStats. If partition_token is set, query_mode can only be set to
* QueryMode.NORMAL.
*/
queryMode: string;
/**
* If this request is resuming a previously interrupted SQL query execution,
* `resume_token` should be copied from the last PartialResultSet yielded
* before the interruption. Doing this enables the new SQL query execution to
* resume where the last one left off. The rest of the request parameters must
* exactly match the request that yielded this token.
*/
resumeToken: string;
/**
* Required. The SQL query string.
*/
sql: string;
/**
* The transaction to use. If none is provided, the default is a temporary
* read-only transaction with strong concurrency.
*/
transaction: Schema$TransactionSelector;
}
/**
* Message representing a single field of a struct.
*/
export interface Schema$Field {
/**
* The name of the field. For reads, this is the column name. For SQL queries,
* it is the column alias (e.g., `"Word"` in the query `"SELECT
* 'hello' AS Word"`), or the column name (e.g.,
* `"ColName"` in the query `"SELECT ColName FROM
* Table"`). Some columns might have an empty name (e.g., !"SELECT
* UPPER(ColName)"`). Note that a query result can contain multiple
* fields with the same name.
*/
name: string;
/**
* The type of the field.
*/
type: Schema$Type;
}
/**
* The response for GetDatabaseDdl.
*/
export interface Schema$GetDatabaseDdlResponse {
/**
* A list of formatted DDL statements defining the schema of the database
* specified in the request.
*/
statements: string[];
}
/**
* Request message for `GetIamPolicy` method.
*/
export interface Schema$GetIamPolicyRequest {
}
/**
* An isolated set of Cloud Spanner resources on which databases can be hosted.
*/
export interface Schema$Instance {
/**
* Required. The name of the instance's configuration. Values are of the
* form `projects/<project>/instanceConfigs/<configuration>`. See
* also InstanceConfig and ListInstanceConfigs.
*/
config: string;
/**
* Required. The descriptive name for this instance as it appears in UIs. Must
* be unique per project and between 4 and 30 characters in length.
*/
displayName: string;
/**
* Cloud Labels are a flexible and lightweight mechanism for organizing cloud
* resources into groups that reflect a customer's organizational needs
* and deployment strategies. Cloud Labels can be used to filter collections
* of resources. They can be used to control how resource metrics are
* aggregated. And they can be used as arguments to policy management rules
* (e.g. route, firewall, load balancing, etc.). * Label keys must be
* between 1 and 63 characters long and must conform to the following
* regular expression: `[a-z]([-a-z0-9]*[a-z0-9])?`. * Label values must be
* between 0 and 63 characters long and must conform to the regular
* expression `([a-z]([-a-z0-9]*[a-z0-9])?)?`. * No more than 64 labels can
* be associated with a given resource. See https://goo.gl/xmQnxf for more
* information on and examples of labels. If you plan to use labels in your
* own code, please note that additional characters may be allowed in the
* future. And so you are advised to use an internal label representation,
* such as JSON, which doesn't rely upon specific characters being
* disallowed. For example, representing labels as the string: name +
* "_" + value would prove problematic if we were to allow
* "_" in a future release.
*/
labels: any;
/**
* Required. A unique identifier for the instance, which cannot be changed
* after the instance is created. Values are of the form
* `projects/<project>/instances/a-z*[a-z0-9]`. The final segment of the
* name must be between 6 and 30 characters in length.
*/
name: string;
/**
* Required. The number of nodes allocated to this instance. This may be zero
* in API responses for instances that are not yet in state `READY`. See [the
* documentation](https://cloud.google.com/spanner/docs/instances#node_count)
* for more information about nodes.
*/
nodeCount: number;
/**
* Output only. The current instance state. For CreateInstance, the state must
* be either omitted or set to `CREATING`. For UpdateInstance, the state must
* be either omitted or set to `READY`.
*/
state: string;
}
/**
* A possible configuration for a Cloud Spanner instance. Configurations define
* the geographic placement of nodes and their replication.
*/
export interface Schema$InstanceConfig {
/**
* The name of this instance configuration as it appears in UIs.
*/
displayName: string;
/**
* A unique identifier for the instance configuration. Values are of the form
* `projects/<project>/instanceConfigs/a-z*`
*/
name: string;
}
/**
* KeyRange represents a range of rows in a table or index. A range has a start
* key and an end key. These keys can be open or closed, indicating if the range
* includes rows with that key. Keys are represented by lists, where the ith
* value in the list corresponds to the ith component of the table or index
* primary key. Individual values are encoded as described here. For example,
* consider the following table definition: CREATE TABLE UserEvents (
* UserName STRING(MAX), EventDate STRING(10) ) PRIMARY KEY(UserName,
* EventDate); The following keys name rows in this table: "Bob",
* "2014-09-23" Since the `UserEvents` table's `PRIMARY KEY`
* clause names two columns, each `UserEvents` key has two elements; the first
* is the `UserName`, and the second is the `EventDate`. Key ranges with
* multiple components are interpreted lexicographically by component using the
* table or index key's declared sort order. For example, the following
* range returns all events for user `"Bob"` that occurred in the year
* 2015: "start_closed": ["Bob",
* "2015-01-01"] "end_closed": ["Bob",
* "2015-12-31"] Start and end keys can omit trailing key components.
* This affects the inclusion and exclusion of rows that exactly match the
* provided key components: if the key is closed, then rows that exactly match
* the provided components are included; if the key is open, then rows that
* exactly match are not included. For example, the following range includes
* all events for `"Bob"` that occurred during and after the year
* 2000: "start_closed": ["Bob",
* "2000-01-01"] "end_closed": ["Bob"] The
* next example retrieves all events for `"Bob"`:
* "start_closed": ["Bob"] "end_closed":
* ["Bob"] To retrieve events before the year 2000:
* "start_closed": ["Bob"] "end_open":
* ["Bob", "2000-01-01"] The following range includes all
* rows in the table: "start_closed": [] "end_closed":
* [] This range returns all users whose `UserName` begins with any character
* from A to C: "start_closed": ["A"]
* "end_open": ["D"] This range returns all users whose
* `UserName` begins with B: "start_closed": ["B"]
* "end_open": ["C"] Key ranges honor column sort order.
* For example, suppose a table is defined as follows: CREATE TABLE
* DescendingSortedTable { Key INT64, ... ) PRIMARY KEY(Key
* DESC); The following range retrieves all rows with key values between 1 and
* 100 inclusive: "start_closed": ["100"]
* "end_closed": ["1"] Note that 100 is passed as the
* start, and 1 is passed as the end, because `Key` is a descending column in
* the schema.
*/
export interface Schema$KeyRange {
/**
* If the end is closed, then the range includes all rows whose first
* `len(end_closed)` key columns exactly match `end_closed`.
*/
endClosed: any[];
/**
* If the end is open, then the range excludes rows whose first
* `len(end_open)` key columns exactly match `end_open`.
*/
endOpen: any[];
/**
* If the start is closed, then the range includes all rows whose first
* `len(start_closed)` key columns exactly match `start_closed`.
*/
startClosed: any[];
/**
* If the start is open, then the range excludes rows whose first
* `len(start_open)` key columns exactly match `start_open`.
*/
startOpen: any[];
}
/**
* `KeySet` defines a collection of Cloud Spanner keys and/or key ranges. All
* the keys are expected to be in the same table or index. The keys need not be
* sorted in any particular way. If the same key is specified multiple times in
* the set (for example if two ranges, two keys, or a key and a range overlap),
* Cloud Spanner behaves as if the key were only specified once.
*/
export interface Schema$KeySet {
/**
* For convenience `all` can be set to `true` to indicate that this `KeySet`
* matches all keys in the table or index. Note that any keys specified in
* `keys` or `ranges` are only yielded once.
*/
all: boolean;
/**
* A list of specific keys. Entries in `keys` should have exactly as many
* elements as there are columns in the primary or index key with which this
* `KeySet` is used. Individual key values are encoded as described here.
*/
keys: any[][];
/**
* A list of key ranges. See KeyRange for more information about key range
* specifications.
*/
ranges: Schema$KeyRange[];
}
/**
* The response for ListDatabases.
*/
export interface Schema$ListDatabasesResponse {
/**
* Databases that matched the request.
*/
databases: Schema$Database[];
/**
* `next_page_token` can be sent in a subsequent ListDatabases call to fetch
* more of the matching databases.
*/
nextPageToken: string;
}
/**
* The response for ListInstanceConfigs.
*/
export interface Schema$ListInstanceConfigsResponse {
/**
* The list of requested instance configurations.
*/
instanceConfigs: Schema$InstanceConfig[];
/**
* `next_page_token` can be sent in a subsequent ListInstanceConfigs call to
* fetch more of the matching instance configurations.
*/
nextPageToken: string;
}
/**
* The response for ListInstances.
*/
export interface Schema$ListInstancesResponse {
/**
* The list of requested instances.
*/
instances: Schema$Instance[];
/**
* `next_page_token` can be sent in a subsequent ListInstances call to fetch
* more of the matching instances.
*/
nextPageToken: string;
}
/**
* The response message for Operations.ListOperations.
*/
export interface Schema$ListOperationsResponse {
/**
* The standard List next-page token.
*/
nextPageToken: string;
/**
* A list of operations that matches the specified filter in the request.
*/
operations: Schema$Operation[];
}
/**
* The response for ListSessions.
*/
export interface Schema$ListSessionsResponse {
/**
* `next_page_token` can be sent in a subsequent ListSessions call to fetch
* more of the matching sessions.
*/
nextPageToken: string;
/**
* The list of requested sessions.
*/
sessions: Schema$Session[];
}
/**
* A modification to one or more Cloud Spanner rows. Mutations can be applied
* to a Cloud Spanner database by sending them in a Commit call.
*/
export interface Schema$Mutation {
/**
* Delete rows from a table. Succeeds whether or not the named rows were
* present.
*/
delete: Schema$Delete;
/**
* Insert new rows in a table. If any of the rows already exist, the write or
* transaction fails with error `ALREADY_EXISTS`.
*/
insert: Schema$Write;
/**
* Like insert, except that if the row already exists, then its column values
* are overwritten with the ones provided. Any column values not explicitly
* written are preserved.
*/
insertOrUpdate: Schema$Write;
/**
* Like insert, except that if the row already exists, it is deleted, and the
* column values provided are inserted instead. Unlike insert_or_update, this
* means any values not explicitly written become `NULL`.
*/
replace: Schema$Write;
/**
* Update existing rows in a table. If any of the rows does not already exist,
* the transaction fails with error `NOT_FOUND`.
*/
update: Schema$Write;
}
/**
* This resource represents a long-running operation that is the result of a
* network API call.
*/
export interface Schema$Operation {
/**
* If the value is `false`, it means the operation is still in progress. If
* `true`, the operation is completed, and either `error` or `response` is
* available.
*/
done: boolean;
/**
* The error result of the operation in case of failure or cancellation.
*/
error: Schema$Status;
/**
* Service-specific metadata associated with the operation. It typically
* contains progress information and common metadata such as create time. Some
* services might not provide such metadata. Any method that returns a
* long-running operation should document the metadata type, if any.
*/
metadata: any;
/**
* The server-assigned name, which is only unique within the same service that
* originally returns it. If you use the default HTTP mapping, the `name`
* should have the format of `operations/some/unique/name`.
*/
name: string;
/**
* The normal response of the operation in case of success. If the original
* method returns no data on success, such as `Delete`, the response is
* `google.protobuf.Empty`. If the original method is standard
* `Get`/`Create`/`Update`, the response should be the resource. For other
* methods, the response should have the type `XxxResponse`, where `Xxx` is
* the original method name. For example, if the original method name is
* `TakeSnapshot()`, the inferred response type is `TakeSnapshotResponse`.
*/
response: any;
}
/**
* Partial results from a streaming read or SQL query. Streaming reads and SQL
* queries better tolerate large result sets, large rows, and large values, but
* are a little trickier to consume.
*/
export interface Schema$PartialResultSet {
/**
* If true, then the final value in values is chunked, and must be combined
* with more values from subsequent `PartialResultSet`s to obtain a complete
* field value.
*/
chunkedValue: boolean;
/**
* Metadata about the result set, such as row type information. Only present
* in the first response.
*/
metadata: Schema$ResultSetMetadata;
/**
* Streaming calls might be interrupted for a variety of reasons, such as TCP
* connection loss. If this occurs, the stream of results can be resumed by
* re-sending the original request and including `resume_token`. Note that
* executing any other transaction in the same session invalidates the token.
*/
resumeToken: string;
/**
* Query plan and execution statistics for the query that produced this
* streaming result set. These can be requested by setting
* ExecuteSqlRequest.query_mode and are sent only once with the last response
* in the stream.
*/
stats: Schema$ResultSetStats;
/**
* A streamed result set consists of a stream of values, which might be split
* into many `PartialResultSet` messages to accommodate large rows and/or
* large values. Every N complete values defines a row, where N is equal to
* the number of entries in metadata.row_type.fields. Most values are encoded
* based on type as described here. It is possible that the last value in
* values is "chunked", meaning that the rest of the value is sent
* in subsequent `PartialResultSet`(s). This is denoted by the chunked_value
* field. Two or more chunked values can be merged to form a complete value as
* follows: * `bool/number/null`: cannot be chunked * `string`:
* concatenate the strings * `list`: concatenate the lists. If the last
* element in a list is a `string`, `list`, or `object`, merge it with the
* first element in the next list by applying these rules recursively. *
* `object`: concatenate the (field name, field value) pairs. If a field
* name is duplicated, then apply these rules recursively to merge the
* field values. Some examples of merging: # Strings are concatenated.
* "foo", "bar" => "foobar" # Lists of
* non-strings are concatenated. [2, 3], [4] => [2, 3, 4] # Lists
* are concatenated, but the last and first elements are merged # because
* they are strings. ["a", "b"], ["c",
* "d"] => ["a", "bc", "d"] #
* Lists are concatenated, but the last and first elements are merged #
* because they are lists. Recursively, the last and first elements # of
* the inner lists are merged because they are strings. ["a",
* ["b", "c"]], [["d"], "e"] =>
* ["a", ["b", "cd"], "e"] #
* Non-overlapping object fields are combined. {"a":
* "1"}, {"b": "2"} => {"a":
* "1", "b": 2"} # Overlapping object fields are
* merged. {"a": "1"}, {"a": "2"}
* => {"a": "12"} # Examples of merging objects
* containing lists of strings. {"a": ["1"]},
* {"a": ["2"]} => {"a": ["12"]}
* For a more complete example, suppose a streaming SQL query is yielding a
* result set whose rows contain a single string field. The following
* `PartialResultSet`s might be yielded: { "metadata": {
* ... } "values": ["Hello", "W"]
* "chunked_value": true "resume_token":
* "Af65..." } { "values": ["orl"]
* "chunked_value": true "resume_token":
* "Bqp2..." } { "values": ["d"]
* "resume_token": "Zx1B..." } This sequence of
* `PartialResultSet`s encodes two rows, one containing the field value
* `"Hello"`, and a second containing the field value
* `"World" = "W" + "orl" + "d"`.
*/
values: any[];
}
/**
* Information returned for each partition returned in a PartitionResponse.
*/
export interface Schema$Partition {
/**
* This token can be passed to Read, StreamingRead, ExecuteSql, or
* ExecuteStreamingSql requests to restrict the results to those identified by
* this partition token.
*/
partitionToken: string;
}
/**
* Options for a PartitionQueryRequest and PartitionReadRequest.
*/
export interface Schema$PartitionOptions {
/**
* **Note:** This hint is currently ignored by PartitionQuery and
* PartitionRead requests. The desired maximum number of partitions to
* return. For example, this may be set to the number of workers available.
* The default for this option is currently 10,000. The maximum value is
* currently 200,000. This is only a hint. The actual number of partitions
* returned may be smaller or larger than this maximum count request.
*/
maxPartitions: string;
/**
* **Note:** This hint is currently ignored by PartitionQuery and
* PartitionRead requests. The desired data size for each partition
* generated. The default for this option is currently 1 GiB. This is only a
* hint. The actual size of each partition may be smaller or larger than this
* size request.
*/
partitionSizeBytes: string;
}
/**
* The request for PartitionQuery
*/
export interface Schema$PartitionQueryRequest {
/**
* The SQL query string can contain parameter placeholders. A parameter
* placeholder consists of `'@'` followed by the parameter name.
* Parameter names consist of any combination of letters, numbers, and
* underscores. Parameters can appear anywhere that a literal value is
* expected. The same parameter name can be used more than once, for example:
* `"WHERE id > @msg_id AND id < @msg_id + 100"` It is an
* error to execute an SQL query with unbound parameters. Parameter values
* are specified using `params`, which is a JSON object whose keys are
* parameter names, and whose values are the corresponding parameter values.
*/
params: any;
/**
* It is not always possible for Cloud Spanner to infer the right SQL type
* from a JSON value. For example, values of type `BYTES` and values of type
* `STRING` both appear in params as JSON strings. In these cases,
* `param_types` can be used to specify the exact SQL type for some or all of
* the SQL query parameters. See the definition of Type for more information
* about SQL types.
*/
paramTypes: any;
/**
* Additional options that affect how many partitions are created.
*/
partitionOptions: Schema$PartitionOptions;
/**
* The query request to generate partitions for. The request will fail if the
* query is not root partitionable. The query plan of a root partitionable
* query has a single distributed union operator. A distributed union operator
* conceptually divides one or more tables into multiple splits, remotely
* evaluates a subquery independently on each split, and then unions all
* results.
*/
sql: string;
/**
* Read only snapshot transactions are supported, read/write and single use
* transactions are not.
*/
transaction: Schema$TransactionSelector;
}
/**
* The request for PartitionRead
*/
export interface Schema$PartitionReadRequest {
/**
* The columns of table to be returned for each row matching this request.
*/
columns: string[];
/**
* If non-empty, the name of an index on table. This index is used instead of
* the table primary key when interpreting key_set and sorting result rows.
* See key_set for further information.
*/
index: string;
/**
* Required. `key_set` identifies the rows to be yielded. `key_set` names the
* primary keys of the rows in table to be yielded, unless index is present.
* If index is present, then key_set instead names index keys in index. It is
* not an error for the `key_set` to name rows that do not exist in the
* database. Read yields nothing for nonexistent rows.
*/
keySet: Schema$KeySet;
/**
* Additional options that affect how many partitions are created.
*/
partitionOptions: Schema$PartitionOptions;
/**
* Required. The name of the table in the database to be read.
*/
table: string;
/**
* Read only snapshot transactions are supported, read/write and single use
* transactions are not.
*/
transaction: Schema$TransactionSelector;
}
/**
* The response for PartitionQuery or PartitionRead
*/
export interface Schema$PartitionResponse {
/**
* Partitions created by this request.
*/
partitions: Schema$Partition[];
/**
* Transaction created by this request.
*/
transaction: Schema$Transaction;
}
/**
* Node information for nodes appearing in a QueryPlan.plan_nodes.
*/
export interface Schema$PlanNode {
/**
* List of child node `index`es and their relationship to this parent.
*/
childLinks: Schema$ChildLink[];
/**
* The display name for the node.
*/
displayName: string;
/**
* The execution statistics associated with the node, contained in a group of
* key-value pairs. Only present if the plan was returned as a result of a
* profile query. For example, number of executions, number of rows/time per
* execution etc.
*/
executionStats: any;
/**
* The `PlanNode`'s index in node list.
*/
index: number;
/**
* Used to determine the type of node. May be needed for visualizing different
* kinds of nodes differently. For example, If the node is a SCALAR node, it
* will have a condensed representation which can be used to directly embed a
* description of the node in its parent.
*/
kind: string;
/**
* Attributes relevant to the node contained in a group of key-value pairs.
* For example, a Parameter Reference node could have the following
* information in its metadata: { "parameter_reference":
* "param1", "parameter_type": "array" }
*/
metadata: any;
/**
* Condensed representation for SCALAR nodes.
*/
shortRepresentation: Schema$ShortRepresentation;
}
/**
* Defines an Identity and Access Management (IAM) policy. It is used to specify
* access control policies for Cloud Platform resources. A `Policy` consists
* of a list of `bindings`. A `Binding` binds a list of `members` to a `role`,
* where the members can be user accounts, Google groups, Google domains, and
* service accounts. A `role` is a named list of permissions defined by IAM.
* **Example** { "bindings": [ { "role":
* "roles/owner", "members": [
* "user:mike@example.com", "group:admins@example.com",
* "domain:google.com",
* "serviceAccount:my-other-app@appspot.gserviceaccount.com", ] }, {
* "role": "roles/viewer", "members":
* ["user:sean@example.com"] } ] } For a
* description of IAM and its features, see the [IAM developer's
* guide](https://cloud.google.com/iam/docs).
*/
export interface Schema$Policy {
/**
* Associates a list of `members` to a `role`. `bindings` with no members will
* result in an error.
*/
bindings: Schema$Binding[];
/**
* `etag` is used for optimistic concurrency control as a way to help prevent
* simultaneous updates of a policy from overwriting each other. It is
* strongly suggested that systems make use of the `etag` in the
* read-modify-write cycle to perform policy updates in order to avoid race
* conditions: An `etag` is returned in the response to `getIamPolicy`, and
* systems are expected to put that etag in the request to `setIamPolicy` to
* ensure that their change will be applied to the same version of the policy.
* If no `etag` is provided in the call to `setIamPolicy`, then the existing
* policy is overwritten blindly.
*/
etag: string;
/**
* Deprecated.
*/
version: number;
}
/**
* Contains an ordered list of nodes appearing in the query plan.
*/
export interface Schema$QueryPlan {
/**
* The nodes in the query plan. Plan nodes are returned in pre-order starting
* with the plan root. Each PlanNode's `id` corresponds to its index in
* `plan_nodes`.
*/
planNodes: Schema$PlanNode[];
}
/**
* Message type to initiate a read-only transaction.
*/
export interface Schema$ReadOnly {
/**
* Executes all reads at a timestamp that is `exact_staleness` old. The
* timestamp is chosen soon after the read is started. Guarantees that all
* writes that have committed more than the specified number of seconds ago
* are visible. Because Cloud Spanner chooses the exact timestamp, this mode
* works even if the client's local clock is substantially skewed from
* Cloud Spanner commit timestamps. Useful for reading at nearby replicas
* without the distributed timestamp negotiation overhead of `max_staleness`.
*/
exactStaleness: string;
/**
* Read data at a timestamp >= `NOW - max_staleness` seconds. Guarantees
* that all writes that have committed more than the specified number of
* seconds ago are visible. Because Cloud Spanner chooses the exact timestamp,
* this mode works even if the client's local clock is substantially
* skewed from Cloud Spanner commit timestamps. Useful for reading the
* freshest data available at a nearby replica, while bounding the possible
* staleness if the local replica has fallen behind. Note that this option
* can only be used in single-use transactions.
*/
maxStaleness: string;
/**
* Executes all reads at a timestamp >= `min_read_timestamp`. This is
* useful for requesting fresher data than some previous read, or data that is
* fresh enough to observe the effects of some previously committed
* transaction whose timestamp is known. Note that this option can only be
* used in single-use transactions. A timestamp in RFC3339 UTC
* \"Zulu\" format, accurate to nanoseconds. Example:
* `"2014-10-02T15:01:23.045123456Z"`.
*/
minReadTimestamp: string;
/**
* Executes all reads at the given timestamp. Unlike other modes, reads at a
* specific timestamp are repeatable; the same read at the same timestamp
* always returns the same data. If the timestamp is in the future, the read
* will block until the specified timestamp, modulo the read's deadline.
* Useful for large scale consistent reads such as mapreduces, or for
* coordinating many reads against a consistent snapshot of the data. A
* timestamp in RFC3339 UTC \"Zulu\" format, accurate to
* nanoseconds. Example: `"2014-10-02T15:01:23.045123456Z"`.
*/
readTimestamp: string;
/**
* If true, the Cloud Spanner-selected read timestamp is included in the
* Transaction message that describes the transaction.
*/
returnReadTimestamp: boolean;
/**
* Read at a timestamp where all previously committed transactions are
* visible.
*/
strong: boolean;
}
/**
* The request for Read and StreamingRead.
*/
export interface Schema$ReadRequest {
/**
* The columns of table to be returned for each row matching this request.
*/
columns: string[];
/**
* If non-empty, the name of an index on table. This index is used instead of
* the table primary key when interpreting key_set and sorting result rows.
* See key_set for further information.
*/
index: string;
/**
* Required. `key_set` identifies the rows to be yielded. `key_set` names the
* primary keys of the rows in table to be yielded, unless index is present.
* If index is present, then key_set instead names index keys in index. If
* the partition_token field is empty, rows are yielded in table primary key
* order (if index is empty) or index key order (if index is non-empty). If
* the partition_token field is not empty, rows will be yielded in an
* unspecified order. It is not an error for the `key_set` to name rows that
* do not exist in the database. Read yields nothing for nonexistent rows.
*/
keySet: Schema$KeySet;
/**
* If greater than zero, only the first `limit` rows are yielded. If `limit`
* is zero, the default is no limit. A limit cannot be specified if
* `partition_token` is set.
*/
limit: string;
/**
* If present, results will be restricted to the specified partition
* previously created using PartitionRead(). There must be an exact match
* for the values of fields common to this message and the
* PartitionReadRequest message used to create this partition_token.
*/
partitionToken: string;
/**
* If this request is resuming a previously interrupted read, `resume_token`
* should be copied from the last PartialResultSet yielded before the
* interruption. Doing this enables the new read to resume where the last read
* left off. The rest of the request parameters must exactly match the request
* that yielded this token.
*/
resumeToken: string;
/**
* Required. The name of the table in the database to be read.
*/
table: string;
/**
* The transaction to use. If none is provided, the default is a temporary
* read-only transaction with strong concurrency.
*/
transaction: Schema$TransactionSelector;
}
/**
* Message type to initiate a read-write transaction. Currently this transaction
* type has no options.
*/
export interface Schema$ReadWrite {
}
/**
* Results from Read or ExecuteSql.
*/
export interface Schema$ResultSet {
/**
* Metadata about the result set, such as row type information.
*/
metadata: Schema$ResultSetMetadata;
/**
* Each element in `rows` is a row whose format is defined by
* metadata.row_type. The ith element in each row matches the ith field in
* metadata.row_type. Elements are encoded based on type as described here.
*/
rows: any[][];
/**
* Query plan and execution statistics for the query that produced this result
* set. These can be requested by setting ExecuteSqlRequest.query_mode.
*/
stats: Schema$ResultSetStats;
}
/**
* Metadata about a ResultSet or PartialResultSet.
*/
export interface Schema$ResultSetMetadata {
/**
* Indicates the field names and types for the rows in the result set. For
* example, a SQL query like `"SELECT UserId, UserName FROM Users"`
* could return a `row_type` value like: "fields": [ {
* "name": "UserId", "type": { "code":
* "INT64" } }, { "name": "UserName",
* "type": { "code": "STRING" } }, ]
*/
rowType: Schema$StructType;
/**
* If the read or SQL query began a transaction as a side-effect, the
* information about the new transaction is yielded here.
*/
transaction: Schema$Transaction;
}
/**
* Additional statistics about a ResultSet or PartialResultSet.
*/
export interface Schema$ResultSetStats {
/**
* QueryPlan for the query associated with this result.
*/
queryPlan: Schema$QueryPlan;
/**
* Aggregated statistics from the execution of the query. Only present when
* the query is profiled. For example, a query could return the statistics as
* follows: { "rows_returned": "3",
* "elapsed_time": "1.22 secs", "cpu_time":
* "1.19 secs" }
*/
queryStats: any;
}
/**
* The request for Rollback.
*/
export interface Schema$RollbackRequest {
/**
* Required. The transaction to roll back.
*/
transactionId: string;
}
/**
* A session in the Cloud Spanner API.
*/
export interface Schema$Session {
/**
* Output only. The approximate timestamp when the session is last used. It is
* typically earlier than the actual last use time.
*/
approximateLastUseTime: string;
/**
* Output only. The timestamp when the session is created.
*/
createTime: string;
/**
* The labels for the session. * Label keys must be between 1 and 63
* characters long and must conform to the following regular expression:
* `[a-z]([-a-z0-9]*[a-z0-9])?`. * Label values must be between 0 and 63
* characters long and must conform to the regular expression
* `([a-z]([-a-z0-9]*[a-z0-9])?)?`. * No more than 64 labels can be
* associated with a given session. See https://goo.gl/xmQnxf for more
* information on and examples of labels.
*/
labels: any;
/**
* The name of the session. This is always system-assigned; values provided
* when creating a session are ignored.
*/
name: string;
}
/**
* Request message for `SetIamPolicy` method.
*/
export interface Schema$SetIamPolicyRequest {
/**
* REQUIRED: The complete policy to be applied to the `resource`. The size of
* the policy is limited to a few 10s of KB. An empty policy is a valid policy
* but certain Cloud Platform services (such as Projects) might reject them.
*/
policy: Schema$Policy;
}
/**
* Condensed representation of a node and its subtree. Only present for `SCALAR`
* PlanNode(s).
*/
export interface Schema$ShortRepresentation {
/**
* A string representation of the expression subtree rooted at this node.
*/
description: string;
/**
* A mapping of (subquery variable name) -> (subquery node id) for cases
* where the `description` string of this node references a `SCALAR` subquery
* contained in the expression subtree rooted at this node. The referenced
* `SCALAR` subquery may not necessarily be a direct child of this node.
*/
subqueries: any;
}
/**
* The `Status` type defines a logical error model that is suitable for
* different programming environments, including REST APIs and RPC APIs. It is
* used by [gRPC](https://github.com/grpc). The error model is designed to be:
* - Simple to use and understand for most users - Flexible enough to meet
* unexpected needs # Overview The `Status` message contains three pieces of
* data: error code, error message, and error details. The error code should be
* an enum value of google.rpc.Code, but it may accept additional error codes if
* needed. The error message should be a developer-facing English message that
* helps developers *understand* and *resolve* the error. If a localized
* user-facing error message is needed, put the localized message in the error
* details or localize it in the client. The optional error details may contain
* arbitrary information about the error. There is a predefined set of error
* detail types in the package `google.rpc` that can be used for common error
* conditions. # Language mapping The `Status` message is the logical
* representation of the error model, but it is not necessarily the actual wire
* format. When the `Status` message is exposed in different client libraries
* and different wire protocols, it can be mapped differently. For example, it
* will likely be mapped to some exceptions in Java, but more likely mapped to
* some error codes in C. # Other uses The error model and the `Status`
* message can be used in a variety of environments, either with or without
* APIs, to provide a consist