diff --git a/docs/dyn/spanner_v1.projects.instances.databases.html b/docs/dyn/spanner_v1.projects.instances.databases.html
index f3f5dae98e4..b243135cf97 100644
--- a/docs/dyn/spanner_v1.projects.instances.databases.html
+++ b/docs/dyn/spanner_v1.projects.instances.databases.html
@@ -152,6 +152,7 @@ Method Details
"extraStatements": [ # Optional. A 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.
"A String",
],
+ "protoDescriptors": "A String", # Optional. Proto descriptors used by CREATE/ALTER PROTO BUNDLE statements in 'extra_statements' above. Contains a protobuf-serialized [google.protobuf.FileDescriptorSet](https://github.com/protocolbuffers/protobuf/blob/main/src/google/protobuf/descriptor.proto). To generate it, [install](https://grpc.io/docs/protoc-installation/) and run `protoc` with --include_imports and --descriptor_set_out. For example, to generate for moon/shot/app.proto, run """ $protoc --proto_path=/app_path --proto_path=/lib_path \ --include_imports \ --descriptor_set_out=descriptors.data \ moon/shot/app.proto """ For more details, see protobuffer [self description](https://developers.google.com/protocol-buffers/docs/techniques#self-description).
}
x__xgafv: string, V1 error format.
@@ -268,6 +269,7 @@ Method Details
An object of the form:
{ # The response for GetDatabaseDdl.
+ "protoDescriptors": "A String", # Proto descriptors stored in the database. Contains a protobuf-serialized [google.protobuf.FileDescriptorSet](https://github.com/protocolbuffers/protobuf/blob/main/src/google/protobuf/descriptor.proto). For more details, see protobuffer [self description](https://developers.google.com/protocol-buffers/docs/techniques#self-description).
"statements": [ # A list of formatted DDL statements defining the schema of the database specified in the request.
"A String",
],
@@ -741,6 +743,7 @@ Method Details
{ # Enqueues the given DDL statements to be applied, in order but not necessarily all at once, to the database schema at some point (or points) in the future. The server checks that the statements are executable (syntactically valid, name tables that exist, etc.) before enqueueing them, but they may still fail upon later execution (e.g., if a statement from another batch of statements is applied first and it conflicts in some way, or if there is some data-related problem like a `NULL` value in a column to which `NOT NULL` would be added). If a statement fails, all subsequent statements in the batch are automatically cancelled. Each batch of statements is assigned a name which can be used with the Operations API to monitor progress. See the operation_id field for more details.
"operationId": "A String", # If empty, the new update request is assigned an automatically-generated operation ID. Otherwise, `operation_id` is used to construct the name of the resulting Operation. Specifying an explicit operation ID simplifies determining whether the statements were executed in the event that the UpdateDatabaseDdl call is replayed, or the return value is otherwise lost: the database and `operation_id` fields can be combined to form the name of the resulting longrunning.Operation: `/operations/`. `operation_id` should be unique within the database, and must be a valid identifier: `a-z*`. Note that automatically-generated operation IDs always begin with an underscore. If the named operation already exists, UpdateDatabaseDdl returns `ALREADY_EXISTS`.
+ "protoDescriptors": "A String", # Optional. Proto descriptors used by CREATE/ALTER PROTO BUNDLE statements. Contains a protobuf-serialized [google.protobuf.FileDescriptorSet](https://github.com/protocolbuffers/protobuf/blob/main/src/google/protobuf/descriptor.proto). To generate it, [install](https://grpc.io/docs/protoc-installation/) and run `protoc` with --include_imports and --descriptor_set_out. For example, to generate for moon/shot/app.proto, run """ $protoc --proto_path=/app_path --proto_path=/lib_path \ --include_imports \ --descriptor_set_out=descriptors.data \ moon/shot/app.proto """ For more details, see protobuffer [self description](https://developers.google.com/protocol-buffers/docs/techniques#self-description).
"statements": [ # Required. DDL statements to be applied to the database.
"A String",
],
diff --git a/docs/dyn/spanner_v1.projects.instances.databases.sessions.html b/docs/dyn/spanner_v1.projects.instances.databases.sessions.html
index 2bb6eec444a..4db06328cdf 100644
--- a/docs/dyn/spanner_v1.projects.instances.databases.sessions.html
+++ b/docs/dyn/spanner_v1.projects.instances.databases.sessions.html
@@ -427,6 +427,7 @@ Method Details
"a_key": { # `Type` indicates the type of a Cloud Spanner value, as might be stored in a table cell or returned from an SQL query.
"arrayElementType": # Object with schema name: Type # If code == ARRAY, then `array_element_type` is the type of the array elements.
"code": "A String", # Required. The TypeCode for this type.
+ "protoTypeFqn": "A String", # If code == PROTO or code == ENUM, then `proto_type_fqn` is the fully qualified name of the proto type representing the proto/enum definition.
"structType": # Object with schema name: StructType # If code == STRUCT, then `struct_type` provides type information for the struct's fields.
"typeAnnotation": "A String", # The TypeAnnotationCode that disambiguates SQL type that Spanner will use to represent values of this type during query processing. This is necessary for some type codes because a single TypeCode can be mapped to different SQL types depending on the SQL dialect. type_annotation typically is not needed to process the content of a value (it doesn't affect serialization) and clients can ignore it on the read path.
},
@@ -491,6 +492,7 @@ Method Details
"type": { # `Type` indicates the type of a Cloud Spanner value, as might be stored in a table cell or returned from an SQL query. # The type of the field.
"arrayElementType": # Object with schema name: Type # If code == ARRAY, then `array_element_type` is the type of the array elements.
"code": "A String", # Required. The TypeCode for this type.
+ "protoTypeFqn": "A String", # If code == PROTO or code == ENUM, then `proto_type_fqn` is the fully qualified name of the proto type representing the proto/enum definition.
"structType": # Object with schema name: StructType # If code == STRUCT, then `struct_type` provides type information for the struct's fields.
"typeAnnotation": "A String", # The TypeAnnotationCode that disambiguates SQL type that Spanner will use to represent values of this type during query processing. This is necessary for some type codes because a single TypeCode can be mapped to different SQL types depending on the SQL dialect. type_annotation typically is not needed to process the content of a value (it doesn't affect serialization) and clients can ignore it on the read path.
},
@@ -508,6 +510,7 @@ Method Details
"type": { # `Type` indicates the type of a Cloud Spanner value, as might be stored in a table cell or returned from an SQL query. # The type of the field.
"arrayElementType": # Object with schema name: Type # If code == ARRAY, then `array_element_type` is the type of the array elements.
"code": "A String", # Required. The TypeCode for this type.
+ "protoTypeFqn": "A String", # If code == PROTO or code == ENUM, then `proto_type_fqn` is the fully qualified name of the proto type representing the proto/enum definition.
"structType": # Object with schema name: StructType # If code == STRUCT, then `struct_type` provides type information for the struct's fields.
"typeAnnotation": "A String", # The TypeAnnotationCode that disambiguates SQL type that Spanner will use to represent values of this type during query processing. This is necessary for some type codes because a single TypeCode can be mapped to different SQL types depending on the SQL dialect. type_annotation typically is not needed to process the content of a value (it doesn't affect serialization) and clients can ignore it on the read path.
},
@@ -583,6 +586,7 @@ Method Details
"a_key": { # `Type` indicates the type of a Cloud Spanner value, as might be stored in a table cell or returned from an SQL query.
"arrayElementType": # Object with schema name: Type # If code == ARRAY, then `array_element_type` is the type of the array elements.
"code": "A String", # Required. The TypeCode for this type.
+ "protoTypeFqn": "A String", # If code == PROTO or code == ENUM, then `proto_type_fqn` is the fully qualified name of the proto type representing the proto/enum definition.
"structType": # Object with schema name: StructType # If code == STRUCT, then `struct_type` provides type information for the struct's fields.
"typeAnnotation": "A String", # The TypeAnnotationCode that disambiguates SQL type that Spanner will use to represent values of this type during query processing. This is necessary for some type codes because a single TypeCode can be mapped to different SQL types depending on the SQL dialect. type_annotation typically is not needed to process the content of a value (it doesn't affect serialization) and clients can ignore it on the read path.
},
@@ -656,6 +660,7 @@ Method Details
"type": { # `Type` indicates the type of a Cloud Spanner value, as might be stored in a table cell or returned from an SQL query. # The type of the field.
"arrayElementType": # Object with schema name: Type # If code == ARRAY, then `array_element_type` is the type of the array elements.
"code": "A String", # Required. The TypeCode for this type.
+ "protoTypeFqn": "A String", # If code == PROTO or code == ENUM, then `proto_type_fqn` is the fully qualified name of the proto type representing the proto/enum definition.
"structType": # Object with schema name: StructType # If code == STRUCT, then `struct_type` provides type information for the struct's fields.
"typeAnnotation": "A String", # The TypeAnnotationCode that disambiguates SQL type that Spanner will use to represent values of this type during query processing. This is necessary for some type codes because a single TypeCode can be mapped to different SQL types depending on the SQL dialect. type_annotation typically is not needed to process the content of a value (it doesn't affect serialization) and clients can ignore it on the read path.
},
@@ -673,6 +678,7 @@ Method Details
"type": { # `Type` indicates the type of a Cloud Spanner value, as might be stored in a table cell or returned from an SQL query. # The type of the field.
"arrayElementType": # Object with schema name: Type # If code == ARRAY, then `array_element_type` is the type of the array elements.
"code": "A String", # Required. The TypeCode for this type.
+ "protoTypeFqn": "A String", # If code == PROTO or code == ENUM, then `proto_type_fqn` is the fully qualified name of the proto type representing the proto/enum definition.
"structType": # Object with schema name: StructType # If code == STRUCT, then `struct_type` provides type information for the struct's fields.
"typeAnnotation": "A String", # The TypeAnnotationCode that disambiguates SQL type that Spanner will use to represent values of this type during query processing. This is necessary for some type codes because a single TypeCode can be mapped to different SQL types depending on the SQL dialect. type_annotation typically is not needed to process the content of a value (it doesn't affect serialization) and clients can ignore it on the read path.
},
@@ -737,6 +743,7 @@ Method Details
"a_key": { # `Type` indicates the type of a Cloud Spanner value, as might be stored in a table cell or returned from an SQL query.
"arrayElementType": # Object with schema name: Type # If code == ARRAY, then `array_element_type` is the type of the array elements.
"code": "A String", # Required. The TypeCode for this type.
+ "protoTypeFqn": "A String", # If code == PROTO or code == ENUM, then `proto_type_fqn` is the fully qualified name of the proto type representing the proto/enum definition.
"structType": # Object with schema name: StructType # If code == STRUCT, then `struct_type` provides type information for the struct's fields.
"typeAnnotation": "A String", # The TypeAnnotationCode that disambiguates SQL type that Spanner will use to represent values of this type during query processing. This is necessary for some type codes because a single TypeCode can be mapped to different SQL types depending on the SQL dialect. type_annotation typically is not needed to process the content of a value (it doesn't affect serialization) and clients can ignore it on the read path.
},
@@ -811,6 +818,7 @@ Method Details
"type": { # `Type` indicates the type of a Cloud Spanner value, as might be stored in a table cell or returned from an SQL query. # The type of the field.
"arrayElementType": # Object with schema name: Type # If code == ARRAY, then `array_element_type` is the type of the array elements.
"code": "A String", # Required. The TypeCode for this type.
+ "protoTypeFqn": "A String", # If code == PROTO or code == ENUM, then `proto_type_fqn` is the fully qualified name of the proto type representing the proto/enum definition.
"structType": # Object with schema name: StructType # If code == STRUCT, then `struct_type` provides type information for the struct's fields.
"typeAnnotation": "A String", # The TypeAnnotationCode that disambiguates SQL type that Spanner will use to represent values of this type during query processing. This is necessary for some type codes because a single TypeCode can be mapped to different SQL types depending on the SQL dialect. type_annotation typically is not needed to process the content of a value (it doesn't affect serialization) and clients can ignore it on the read path.
},
@@ -828,6 +836,7 @@ Method Details
"type": { # `Type` indicates the type of a Cloud Spanner value, as might be stored in a table cell or returned from an SQL query. # The type of the field.
"arrayElementType": # Object with schema name: Type # If code == ARRAY, then `array_element_type` is the type of the array elements.
"code": "A String", # Required. The TypeCode for this type.
+ "protoTypeFqn": "A String", # If code == PROTO or code == ENUM, then `proto_type_fqn` is the fully qualified name of the proto type representing the proto/enum definition.
"structType": # Object with schema name: StructType # If code == STRUCT, then `struct_type` provides type information for the struct's fields.
"typeAnnotation": "A String", # The TypeAnnotationCode that disambiguates SQL type that Spanner will use to represent values of this type during query processing. This is necessary for some type codes because a single TypeCode can be mapped to different SQL types depending on the SQL dialect. type_annotation typically is not needed to process the content of a value (it doesn't affect serialization) and clients can ignore it on the read path.
},
@@ -963,6 +972,7 @@ Method Details
"a_key": { # `Type` indicates the type of a Cloud Spanner value, as might be stored in a table cell or returned from an SQL query.
"arrayElementType": # Object with schema name: Type # If code == ARRAY, then `array_element_type` is the type of the array elements.
"code": "A String", # Required. The TypeCode for this type.
+ "protoTypeFqn": "A String", # If code == PROTO or code == ENUM, then `proto_type_fqn` is the fully qualified name of the proto type representing the proto/enum definition.
"structType": # Object with schema name: StructType # If code == STRUCT, then `struct_type` provides type information for the struct's fields.
"typeAnnotation": "A String", # The TypeAnnotationCode that disambiguates SQL type that Spanner will use to represent values of this type during query processing. This is necessary for some type codes because a single TypeCode can be mapped to different SQL types depending on the SQL dialect. type_annotation typically is not needed to process the content of a value (it doesn't affect serialization) and clients can ignore it on the read path.
},
@@ -1229,6 +1239,7 @@ Method Details
"type": { # `Type` indicates the type of a Cloud Spanner value, as might be stored in a table cell or returned from an SQL query. # The type of the field.
"arrayElementType": # Object with schema name: Type # If code == ARRAY, then `array_element_type` is the type of the array elements.
"code": "A String", # Required. The TypeCode for this type.
+ "protoTypeFqn": "A String", # If code == PROTO or code == ENUM, then `proto_type_fqn` is the fully qualified name of the proto type representing the proto/enum definition.
"structType": # Object with schema name: StructType # If code == STRUCT, then `struct_type` provides type information for the struct's fields.
"typeAnnotation": "A String", # The TypeAnnotationCode that disambiguates SQL type that Spanner will use to represent values of this type during query processing. This is necessary for some type codes because a single TypeCode can be mapped to different SQL types depending on the SQL dialect. type_annotation typically is not needed to process the content of a value (it doesn't affect serialization) and clients can ignore it on the read path.
},
@@ -1246,6 +1257,7 @@ Method Details
"type": { # `Type` indicates the type of a Cloud Spanner value, as might be stored in a table cell or returned from an SQL query. # The type of the field.
"arrayElementType": # Object with schema name: Type # If code == ARRAY, then `array_element_type` is the type of the array elements.
"code": "A String", # Required. The TypeCode for this type.
+ "protoTypeFqn": "A String", # If code == PROTO or code == ENUM, then `proto_type_fqn` is the fully qualified name of the proto type representing the proto/enum definition.
"structType": # Object with schema name: StructType # If code == STRUCT, then `struct_type` provides type information for the struct's fields.
"typeAnnotation": "A String", # The TypeAnnotationCode that disambiguates SQL type that Spanner will use to represent values of this type during query processing. This is necessary for some type codes because a single TypeCode can be mapped to different SQL types depending on the SQL dialect. type_annotation typically is not needed to process the content of a value (it doesn't affect serialization) and clients can ignore it on the read path.
},
@@ -1421,6 +1433,7 @@ Method Details
"type": { # `Type` indicates the type of a Cloud Spanner value, as might be stored in a table cell or returned from an SQL query. # The type of the field.
"arrayElementType": # Object with schema name: Type # If code == ARRAY, then `array_element_type` is the type of the array elements.
"code": "A String", # Required. The TypeCode for this type.
+ "protoTypeFqn": "A String", # If code == PROTO or code == ENUM, then `proto_type_fqn` is the fully qualified name of the proto type representing the proto/enum definition.
"structType": # Object with schema name: StructType # If code == STRUCT, then `struct_type` provides type information for the struct's fields.
"typeAnnotation": "A String", # The TypeAnnotationCode that disambiguates SQL type that Spanner will use to represent values of this type during query processing. This is necessary for some type codes because a single TypeCode can be mapped to different SQL types depending on the SQL dialect. type_annotation typically is not needed to process the content of a value (it doesn't affect serialization) and clients can ignore it on the read path.
},
@@ -1438,6 +1451,7 @@ Method Details
"type": { # `Type` indicates the type of a Cloud Spanner value, as might be stored in a table cell or returned from an SQL query. # The type of the field.
"arrayElementType": # Object with schema name: Type # If code == ARRAY, then `array_element_type` is the type of the array elements.
"code": "A String", # Required. The TypeCode for this type.
+ "protoTypeFqn": "A String", # If code == PROTO or code == ENUM, then `proto_type_fqn` is the fully qualified name of the proto type representing the proto/enum definition.
"structType": # Object with schema name: StructType # If code == STRUCT, then `struct_type` provides type information for the struct's fields.
"typeAnnotation": "A String", # The TypeAnnotationCode that disambiguates SQL type that Spanner will use to represent values of this type during query processing. This is necessary for some type codes because a single TypeCode can be mapped to different SQL types depending on the SQL dialect. type_annotation typically is not needed to process the content of a value (it doesn't affect serialization) and clients can ignore it on the read path.
},
diff --git a/googleapiclient/discovery_cache/documents/spanner.v1.json b/googleapiclient/discovery_cache/documents/spanner.v1.json
index edb98d09c89..0611a116f7f 100644
--- a/googleapiclient/discovery_cache/documents/spanner.v1.json
+++ b/googleapiclient/discovery_cache/documents/spanner.v1.json
@@ -2402,7 +2402,7 @@
}
}
},
- "revision": "20221116",
+ "revision": "20221121",
"rootUrl": "https://spanner.googleapis.com/",
"schemas": {
"Backup": {
@@ -2724,7 +2724,7 @@
"Unspecified. Do not use.",
"This is the default option for CopyBackup when encryption_config is not specified. For example, if the source backup is using `Customer_Managed_Encryption`, the backup will be using the same Cloud KMS key as the source backup.",
"Use Google default encryption.",
- "Use customer managed encryption. If specified, `kms_key_name` must contain a valid Cloud KMS key."
+ "Use customer managed encryption. If specified, either `kms_key_name` or `kms_key_names` must contain valid Cloud KMS key(s)."
],
"type": "string"
},
@@ -2850,6 +2850,11 @@
"type": "string"
},
"type": "array"
+ },
+ "protoDescriptors": {
+ "description": "Optional. Proto descriptors used by CREATE/ALTER PROTO BUNDLE statements in 'extra_statements' above. Contains a protobuf-serialized [google.protobuf.FileDescriptorSet](https://github.com/protocolbuffers/protobuf/blob/main/src/google/protobuf/descriptor.proto). To generate it, [install](https://grpc.io/docs/protoc-installation/) and run `protoc` with --include_imports and --descriptor_set_out. For example, to generate for moon/shot/app.proto, run \"\"\" $protoc --proto_path=/app_path --proto_path=/lib_path \\ --include_imports \\ --descriptor_set_out=descriptors.data \\ moon/shot/app.proto \"\"\" For more details, see protobuffer [self description](https://developers.google.com/protocol-buffers/docs/techniques#self-description).",
+ "format": "byte",
+ "type": "string"
}
},
"type": "object"
@@ -3346,6 +3351,11 @@
"description": "The response for GetDatabaseDdl.",
"id": "GetDatabaseDdlResponse",
"properties": {
+ "protoDescriptors": {
+ "description": "Proto descriptors stored in the database. Contains a protobuf-serialized [google.protobuf.FileDescriptorSet](https://github.com/protocolbuffers/protobuf/blob/main/src/google/protobuf/descriptor.proto). For more details, see protobuffer [self description](https://developers.google.com/protocol-buffers/docs/techniques#self-description).",
+ "format": "byte",
+ "type": "string"
+ },
"statements": {
"description": "A list of formatted DDL statements defining the schema of the database specified in the request.",
"items": {
@@ -5129,7 +5139,9 @@
"ARRAY",
"STRUCT",
"NUMERIC",
- "JSON"
+ "JSON",
+ "PROTO",
+ "ENUM"
],
"enumDescriptions": [
"Not specified.",
@@ -5143,10 +5155,16 @@
"Encoded as `list`, where the list elements are represented according to array_element_type.",
"Encoded as `list`, where list element `i` is represented according to [struct_type.fields[i]][google.spanner.v1.StructType.fields].",
"Encoded as `string`, in decimal format or scientific notation format. Decimal format: `[+-]Digits[.[Digits]]` or `+-.Digits` Scientific notation: `[+-]Digits[.[Digits]][ExponentIndicator[+-]Digits]` or `+-.Digits[ExponentIndicator[+-]Digits]` (ExponentIndicator is `\"e\"` or `\"E\"`)",
- "Encoded as a JSON-formatted `string` as described in RFC 7159. The following rules are applied when parsing JSON input: - Whitespace characters are not preserved. - If a JSON object has duplicate keys, only the first key is preserved. - Members of a JSON object are not guaranteed to have their order preserved. - JSON array elements will have their order preserved."
+ "Encoded as a JSON-formatted `string` as described in RFC 7159. The following rules are applied when parsing JSON input: - Whitespace characters are not preserved. - If a JSON object has duplicate keys, only the first key is preserved. - Members of a JSON object are not guaranteed to have their order preserved. - JSON array elements will have their order preserved.",
+ "Encoded as a base64-encoded `string`, as described in RFC 4648, section 4.",
+ "Encoded as `string`, in decimal format."
],
"type": "string"
},
+ "protoTypeFqn": {
+ "description": "If code == PROTO or code == ENUM, then `proto_type_fqn` is the fully qualified name of the proto type representing the proto/enum definition.",
+ "type": "string"
+ },
"structType": {
"$ref": "StructType",
"description": "If code == STRUCT, then `struct_type` provides type information for the struct's fields."
@@ -5214,6 +5232,11 @@
"description": "If empty, the new update request is assigned an automatically-generated operation ID. Otherwise, `operation_id` is used to construct the name of the resulting Operation. Specifying an explicit operation ID simplifies determining whether the statements were executed in the event that the UpdateDatabaseDdl call is replayed, or the return value is otherwise lost: the database and `operation_id` fields can be combined to form the name of the resulting longrunning.Operation: `/operations/`. `operation_id` should be unique within the database, and must be a valid identifier: `a-z*`. Note that automatically-generated operation IDs always begin with an underscore. If the named operation already exists, UpdateDatabaseDdl returns `ALREADY_EXISTS`.",
"type": "string"
},
+ "protoDescriptors": {
+ "description": "Optional. Proto descriptors used by CREATE/ALTER PROTO BUNDLE statements. Contains a protobuf-serialized [google.protobuf.FileDescriptorSet](https://github.com/protocolbuffers/protobuf/blob/main/src/google/protobuf/descriptor.proto). To generate it, [install](https://grpc.io/docs/protoc-installation/) and run `protoc` with --include_imports and --descriptor_set_out. For example, to generate for moon/shot/app.proto, run \"\"\" $protoc --proto_path=/app_path --proto_path=/lib_path \\ --include_imports \\ --descriptor_set_out=descriptors.data \\ moon/shot/app.proto \"\"\" For more details, see protobuffer [self description](https://developers.google.com/protocol-buffers/docs/techniques#self-description).",
+ "format": "byte",
+ "type": "string"
+ },
"statements": {
"description": "Required. DDL statements to be applied to the database.",
"items": {