You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 

522 lines
21 KiB

  1. // Copyright 2019 Google LLC
  2. //
  3. // Licensed under the Apache License, Version 2.0 (the "License");
  4. // you may not use this file except in compliance with the License.
  5. // You may obtain a copy of the License at
  6. //
  7. // https://www.apache.org/licenses/LICENSE-2.0
  8. //
  9. // Unless required by applicable law or agreed to in writing, software
  10. // distributed under the License is distributed on an "AS IS" BASIS,
  11. // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12. // See the License for the specific language governing permissions and
  13. // limitations under the License.
  14. // Code generated by gapic-generator. DO NOT EDIT.
  15. package database
  16. import (
  17. "context"
  18. "math"
  19. "time"
  20. "cloud.google.com/go/longrunning"
  21. lroauto "cloud.google.com/go/longrunning/autogen"
  22. "github.com/golang/protobuf/proto"
  23. gax "github.com/googleapis/gax-go/v2"
  24. "google.golang.org/api/iterator"
  25. "google.golang.org/api/option"
  26. "google.golang.org/api/transport"
  27. iampb "google.golang.org/genproto/googleapis/iam/v1"
  28. longrunningpb "google.golang.org/genproto/googleapis/longrunning"
  29. databasepb "google.golang.org/genproto/googleapis/spanner/admin/database/v1"
  30. "google.golang.org/grpc"
  31. "google.golang.org/grpc/codes"
  32. "google.golang.org/grpc/metadata"
  33. )
  34. // DatabaseAdminCallOptions contains the retry settings for each method of DatabaseAdminClient.
  35. type DatabaseAdminCallOptions struct {
  36. ListDatabases []gax.CallOption
  37. CreateDatabase []gax.CallOption
  38. GetDatabase []gax.CallOption
  39. UpdateDatabaseDdl []gax.CallOption
  40. DropDatabase []gax.CallOption
  41. GetDatabaseDdl []gax.CallOption
  42. SetIamPolicy []gax.CallOption
  43. GetIamPolicy []gax.CallOption
  44. TestIamPermissions []gax.CallOption
  45. }
  46. func defaultDatabaseAdminClientOptions() []option.ClientOption {
  47. return []option.ClientOption{
  48. option.WithEndpoint("spanner.googleapis.com:443"),
  49. option.WithScopes(DefaultAuthScopes()...),
  50. }
  51. }
  52. func defaultDatabaseAdminCallOptions() *DatabaseAdminCallOptions {
  53. retry := map[[2]string][]gax.CallOption{
  54. {"default", "idempotent"}: {
  55. gax.WithRetry(func() gax.Retryer {
  56. return gax.OnCodes([]codes.Code{
  57. codes.DeadlineExceeded,
  58. codes.Unavailable,
  59. }, gax.Backoff{
  60. Initial: 1000 * time.Millisecond,
  61. Max: 32000 * time.Millisecond,
  62. Multiplier: 1.3,
  63. })
  64. }),
  65. },
  66. }
  67. return &DatabaseAdminCallOptions{
  68. ListDatabases: retry[[2]string{"default", "idempotent"}],
  69. CreateDatabase: retry[[2]string{"default", "non_idempotent"}],
  70. GetDatabase: retry[[2]string{"default", "idempotent"}],
  71. UpdateDatabaseDdl: retry[[2]string{"default", "idempotent"}],
  72. DropDatabase: retry[[2]string{"default", "idempotent"}],
  73. GetDatabaseDdl: retry[[2]string{"default", "idempotent"}],
  74. SetIamPolicy: retry[[2]string{"default", "non_idempotent"}],
  75. GetIamPolicy: retry[[2]string{"default", "idempotent"}],
  76. TestIamPermissions: retry[[2]string{"default", "non_idempotent"}],
  77. }
  78. }
  79. // DatabaseAdminClient is a client for interacting with Cloud Spanner Database Admin API.
  80. //
  81. // Methods, except Close, may be called concurrently. However, fields must not be modified concurrently with method calls.
  82. type DatabaseAdminClient struct {
  83. // The connection to the service.
  84. conn *grpc.ClientConn
  85. // The gRPC API client.
  86. databaseAdminClient databasepb.DatabaseAdminClient
  87. // LROClient is used internally to handle longrunning operations.
  88. // It is exposed so that its CallOptions can be modified if required.
  89. // Users should not Close this client.
  90. LROClient *lroauto.OperationsClient
  91. // The call options for this service.
  92. CallOptions *DatabaseAdminCallOptions
  93. // The x-goog-* metadata to be sent with each request.
  94. xGoogMetadata metadata.MD
  95. }
  96. // NewDatabaseAdminClient creates a new database admin client.
  97. //
  98. // Cloud Spanner Database Admin API
  99. //
  100. // The Cloud Spanner Database Admin API can be used to create, drop, and
  101. // list databases. It also enables updating the schema of pre-existing
  102. // databases.
  103. func NewDatabaseAdminClient(ctx context.Context, opts ...option.ClientOption) (*DatabaseAdminClient, error) {
  104. conn, err := transport.DialGRPC(ctx, append(defaultDatabaseAdminClientOptions(), opts...)...)
  105. if err != nil {
  106. return nil, err
  107. }
  108. c := &DatabaseAdminClient{
  109. conn: conn,
  110. CallOptions: defaultDatabaseAdminCallOptions(),
  111. databaseAdminClient: databasepb.NewDatabaseAdminClient(conn),
  112. }
  113. c.setGoogleClientInfo()
  114. c.LROClient, err = lroauto.NewOperationsClient(ctx, option.WithGRPCConn(conn))
  115. if err != nil {
  116. // This error "should not happen", since we are just reusing old connection
  117. // and never actually need to dial.
  118. // If this does happen, we could leak conn. However, we cannot close conn:
  119. // If the user invoked the function with option.WithGRPCConn,
  120. // we would close a connection that's still in use.
  121. // TODO(pongad): investigate error conditions.
  122. return nil, err
  123. }
  124. return c, nil
  125. }
  126. // Connection returns the client's connection to the API service.
  127. func (c *DatabaseAdminClient) Connection() *grpc.ClientConn {
  128. return c.conn
  129. }
  130. // Close closes the connection to the API service. The user should invoke this when
  131. // the client is no longer required.
  132. func (c *DatabaseAdminClient) Close() error {
  133. return c.conn.Close()
  134. }
  135. // setGoogleClientInfo sets the name and version of the application in
  136. // the `x-goog-api-client` header passed on each request. Intended for
  137. // use by Google-written clients.
  138. func (c *DatabaseAdminClient) setGoogleClientInfo(keyval ...string) {
  139. kv := append([]string{"gl-go", versionGo()}, keyval...)
  140. kv = append(kv, "gapic", versionClient, "gax", gax.Version, "grpc", grpc.Version)
  141. c.xGoogMetadata = metadata.Pairs("x-goog-api-client", gax.XGoogHeader(kv...))
  142. }
  143. // ListDatabases lists Cloud Spanner databases.
  144. func (c *DatabaseAdminClient) ListDatabases(ctx context.Context, req *databasepb.ListDatabasesRequest, opts ...gax.CallOption) *DatabaseIterator {
  145. ctx = insertMetadata(ctx, c.xGoogMetadata)
  146. opts = append(c.CallOptions.ListDatabases[0:len(c.CallOptions.ListDatabases):len(c.CallOptions.ListDatabases)], opts...)
  147. it := &DatabaseIterator{}
  148. req = proto.Clone(req).(*databasepb.ListDatabasesRequest)
  149. it.InternalFetch = func(pageSize int, pageToken string) ([]*databasepb.Database, string, error) {
  150. var resp *databasepb.ListDatabasesResponse
  151. req.PageToken = pageToken
  152. if pageSize > math.MaxInt32 {
  153. req.PageSize = math.MaxInt32
  154. } else {
  155. req.PageSize = int32(pageSize)
  156. }
  157. err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error {
  158. var err error
  159. resp, err = c.databaseAdminClient.ListDatabases(ctx, req, settings.GRPC...)
  160. return err
  161. }, opts...)
  162. if err != nil {
  163. return nil, "", err
  164. }
  165. return resp.Databases, resp.NextPageToken, nil
  166. }
  167. fetch := func(pageSize int, pageToken string) (string, error) {
  168. items, nextPageToken, err := it.InternalFetch(pageSize, pageToken)
  169. if err != nil {
  170. return "", err
  171. }
  172. it.items = append(it.items, items...)
  173. return nextPageToken, nil
  174. }
  175. it.pageInfo, it.nextFunc = iterator.NewPageInfo(fetch, it.bufLen, it.takeBuf)
  176. it.pageInfo.MaxSize = int(req.PageSize)
  177. return it
  178. }
  179. // CreateDatabase creates a new Cloud Spanner database and starts to prepare it for serving.
  180. // The returned [long-running operation][google.longrunning.Operation] will
  181. // have a name of the format <database_name>/operations/<operation_id> and
  182. // can be used to track preparation of the database. The
  183. // [metadata][google.longrunning.Operation.metadata] field type is
  184. // [CreateDatabaseMetadata][google.spanner.admin.database.v1.CreateDatabaseMetadata].
  185. // The [response][google.longrunning.Operation.response] field type is
  186. // [Database][google.spanner.admin.database.v1.Database], if successful.
  187. func (c *DatabaseAdminClient) CreateDatabase(ctx context.Context, req *databasepb.CreateDatabaseRequest, opts ...gax.CallOption) (*CreateDatabaseOperation, error) {
  188. ctx = insertMetadata(ctx, c.xGoogMetadata)
  189. opts = append(c.CallOptions.CreateDatabase[0:len(c.CallOptions.CreateDatabase):len(c.CallOptions.CreateDatabase)], opts...)
  190. var resp *longrunningpb.Operation
  191. err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error {
  192. var err error
  193. resp, err = c.databaseAdminClient.CreateDatabase(ctx, req, settings.GRPC...)
  194. return err
  195. }, opts...)
  196. if err != nil {
  197. return nil, err
  198. }
  199. return &CreateDatabaseOperation{
  200. lro: longrunning.InternalNewOperation(c.LROClient, resp),
  201. }, nil
  202. }
  203. // GetDatabase gets the state of a Cloud Spanner database.
  204. func (c *DatabaseAdminClient) GetDatabase(ctx context.Context, req *databasepb.GetDatabaseRequest, opts ...gax.CallOption) (*databasepb.Database, error) {
  205. ctx = insertMetadata(ctx, c.xGoogMetadata)
  206. opts = append(c.CallOptions.GetDatabase[0:len(c.CallOptions.GetDatabase):len(c.CallOptions.GetDatabase)], opts...)
  207. var resp *databasepb.Database
  208. err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error {
  209. var err error
  210. resp, err = c.databaseAdminClient.GetDatabase(ctx, req, settings.GRPC...)
  211. return err
  212. }, opts...)
  213. if err != nil {
  214. return nil, err
  215. }
  216. return resp, nil
  217. }
  218. // UpdateDatabaseDdl updates the schema of a Cloud Spanner database by
  219. // creating/altering/dropping tables, columns, indexes, etc. The returned
  220. // [long-running operation][google.longrunning.Operation] will have a name of
  221. // the format <database_name>/operations/<operation_id> and can be used to
  222. // track execution of the schema change(s). The
  223. // [metadata][google.longrunning.Operation.metadata] field type is
  224. // [UpdateDatabaseDdlMetadata][google.spanner.admin.database.v1.UpdateDatabaseDdlMetadata].
  225. // The operation has no response.
  226. func (c *DatabaseAdminClient) UpdateDatabaseDdl(ctx context.Context, req *databasepb.UpdateDatabaseDdlRequest, opts ...gax.CallOption) (*UpdateDatabaseDdlOperation, error) {
  227. ctx = insertMetadata(ctx, c.xGoogMetadata)
  228. opts = append(c.CallOptions.UpdateDatabaseDdl[0:len(c.CallOptions.UpdateDatabaseDdl):len(c.CallOptions.UpdateDatabaseDdl)], opts...)
  229. var resp *longrunningpb.Operation
  230. err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error {
  231. var err error
  232. resp, err = c.databaseAdminClient.UpdateDatabaseDdl(ctx, req, settings.GRPC...)
  233. return err
  234. }, opts...)
  235. if err != nil {
  236. return nil, err
  237. }
  238. return &UpdateDatabaseDdlOperation{
  239. lro: longrunning.InternalNewOperation(c.LROClient, resp),
  240. }, nil
  241. }
  242. // DropDatabase drops (aka deletes) a Cloud Spanner database.
  243. func (c *DatabaseAdminClient) DropDatabase(ctx context.Context, req *databasepb.DropDatabaseRequest, opts ...gax.CallOption) error {
  244. ctx = insertMetadata(ctx, c.xGoogMetadata)
  245. opts = append(c.CallOptions.DropDatabase[0:len(c.CallOptions.DropDatabase):len(c.CallOptions.DropDatabase)], opts...)
  246. err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error {
  247. var err error
  248. _, err = c.databaseAdminClient.DropDatabase(ctx, req, settings.GRPC...)
  249. return err
  250. }, opts...)
  251. return err
  252. }
  253. // GetDatabaseDdl returns the schema of a Cloud Spanner database as a list of formatted
  254. // DDL statements. This method does not show pending schema updates, those may
  255. // be queried using the [Operations][google.longrunning.Operations] API.
  256. func (c *DatabaseAdminClient) GetDatabaseDdl(ctx context.Context, req *databasepb.GetDatabaseDdlRequest, opts ...gax.CallOption) (*databasepb.GetDatabaseDdlResponse, error) {
  257. ctx = insertMetadata(ctx, c.xGoogMetadata)
  258. opts = append(c.CallOptions.GetDatabaseDdl[0:len(c.CallOptions.GetDatabaseDdl):len(c.CallOptions.GetDatabaseDdl)], opts...)
  259. var resp *databasepb.GetDatabaseDdlResponse
  260. err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error {
  261. var err error
  262. resp, err = c.databaseAdminClient.GetDatabaseDdl(ctx, req, settings.GRPC...)
  263. return err
  264. }, opts...)
  265. if err != nil {
  266. return nil, err
  267. }
  268. return resp, nil
  269. }
  270. // SetIamPolicy sets the access control policy on a database resource. Replaces any
  271. // existing policy.
  272. //
  273. // Authorization requires spanner.databases.setIamPolicy permission on
  274. // [resource][google.iam.v1.SetIamPolicyRequest.resource].
  275. func (c *DatabaseAdminClient) SetIamPolicy(ctx context.Context, req *iampb.SetIamPolicyRequest, opts ...gax.CallOption) (*iampb.Policy, error) {
  276. ctx = insertMetadata(ctx, c.xGoogMetadata)
  277. opts = append(c.CallOptions.SetIamPolicy[0:len(c.CallOptions.SetIamPolicy):len(c.CallOptions.SetIamPolicy)], opts...)
  278. var resp *iampb.Policy
  279. err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error {
  280. var err error
  281. resp, err = c.databaseAdminClient.SetIamPolicy(ctx, req, settings.GRPC...)
  282. return err
  283. }, opts...)
  284. if err != nil {
  285. return nil, err
  286. }
  287. return resp, nil
  288. }
  289. // GetIamPolicy gets the access control policy for a database resource. Returns an empty
  290. // policy if a database exists but does not have a policy set.
  291. //
  292. // Authorization requires spanner.databases.getIamPolicy permission on
  293. // [resource][google.iam.v1.GetIamPolicyRequest.resource].
  294. func (c *DatabaseAdminClient) GetIamPolicy(ctx context.Context, req *iampb.GetIamPolicyRequest, opts ...gax.CallOption) (*iampb.Policy, error) {
  295. ctx = insertMetadata(ctx, c.xGoogMetadata)
  296. opts = append(c.CallOptions.GetIamPolicy[0:len(c.CallOptions.GetIamPolicy):len(c.CallOptions.GetIamPolicy)], opts...)
  297. var resp *iampb.Policy
  298. err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error {
  299. var err error
  300. resp, err = c.databaseAdminClient.GetIamPolicy(ctx, req, settings.GRPC...)
  301. return err
  302. }, opts...)
  303. if err != nil {
  304. return nil, err
  305. }
  306. return resp, nil
  307. }
  308. // TestIamPermissions returns permissions that the caller has on the specified database resource.
  309. //
  310. // Attempting this RPC on a non-existent Cloud Spanner database will result in
  311. // a NOT_FOUND error if the user has spanner.databases.list permission on
  312. // the containing Cloud Spanner instance. Otherwise returns an empty set of
  313. // permissions.
  314. func (c *DatabaseAdminClient) TestIamPermissions(ctx context.Context, req *iampb.TestIamPermissionsRequest, opts ...gax.CallOption) (*iampb.TestIamPermissionsResponse, error) {
  315. ctx = insertMetadata(ctx, c.xGoogMetadata)
  316. opts = append(c.CallOptions.TestIamPermissions[0:len(c.CallOptions.TestIamPermissions):len(c.CallOptions.TestIamPermissions)], opts...)
  317. var resp *iampb.TestIamPermissionsResponse
  318. err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error {
  319. var err error
  320. resp, err = c.databaseAdminClient.TestIamPermissions(ctx, req, settings.GRPC...)
  321. return err
  322. }, opts...)
  323. if err != nil {
  324. return nil, err
  325. }
  326. return resp, nil
  327. }
  328. // DatabaseIterator manages a stream of *databasepb.Database.
  329. type DatabaseIterator struct {
  330. items []*databasepb.Database
  331. pageInfo *iterator.PageInfo
  332. nextFunc func() error
  333. // InternalFetch is for use by the Google Cloud Libraries only.
  334. // It is not part of the stable interface of this package.
  335. //
  336. // InternalFetch returns results from a single call to the underlying RPC.
  337. // The number of results is no greater than pageSize.
  338. // If there are no more results, nextPageToken is empty and err is nil.
  339. InternalFetch func(pageSize int, pageToken string) (results []*databasepb.Database, nextPageToken string, err error)
  340. }
  341. // PageInfo supports pagination. See the google.golang.org/api/iterator package for details.
  342. func (it *DatabaseIterator) PageInfo() *iterator.PageInfo {
  343. return it.pageInfo
  344. }
  345. // Next returns the next result. Its second return value is iterator.Done if there are no more
  346. // results. Once Next returns Done, all subsequent calls will return Done.
  347. func (it *DatabaseIterator) Next() (*databasepb.Database, error) {
  348. var item *databasepb.Database
  349. if err := it.nextFunc(); err != nil {
  350. return item, err
  351. }
  352. item = it.items[0]
  353. it.items = it.items[1:]
  354. return item, nil
  355. }
  356. func (it *DatabaseIterator) bufLen() int {
  357. return len(it.items)
  358. }
  359. func (it *DatabaseIterator) takeBuf() interface{} {
  360. b := it.items
  361. it.items = nil
  362. return b
  363. }
  364. // CreateDatabaseOperation manages a long-running operation from CreateDatabase.
  365. type CreateDatabaseOperation struct {
  366. lro *longrunning.Operation
  367. }
  368. // CreateDatabaseOperation returns a new CreateDatabaseOperation from a given name.
  369. // The name must be that of a previously created CreateDatabaseOperation, possibly from a different process.
  370. func (c *DatabaseAdminClient) CreateDatabaseOperation(name string) *CreateDatabaseOperation {
  371. return &CreateDatabaseOperation{
  372. lro: longrunning.InternalNewOperation(c.LROClient, &longrunningpb.Operation{Name: name}),
  373. }
  374. }
  375. // Wait blocks until the long-running operation is completed, returning the response and any errors encountered.
  376. //
  377. // See documentation of Poll for error-handling information.
  378. func (op *CreateDatabaseOperation) Wait(ctx context.Context, opts ...gax.CallOption) (*databasepb.Database, error) {
  379. var resp databasepb.Database
  380. if err := op.lro.WaitWithInterval(ctx, &resp, 45000*time.Millisecond, opts...); err != nil {
  381. return nil, err
  382. }
  383. return &resp, nil
  384. }
  385. // Poll fetches the latest state of the long-running operation.
  386. //
  387. // Poll also fetches the latest metadata, which can be retrieved by Metadata.
  388. //
  389. // If Poll fails, the error is returned and op is unmodified. If Poll succeeds and
  390. // the operation has completed with failure, the error is returned and op.Done will return true.
  391. // If Poll succeeds and the operation has completed successfully,
  392. // op.Done will return true, and the response of the operation is returned.
  393. // If Poll succeeds and the operation has not completed, the returned response and error are both nil.
  394. func (op *CreateDatabaseOperation) Poll(ctx context.Context, opts ...gax.CallOption) (*databasepb.Database, error) {
  395. var resp databasepb.Database
  396. if err := op.lro.Poll(ctx, &resp, opts...); err != nil {
  397. return nil, err
  398. }
  399. if !op.Done() {
  400. return nil, nil
  401. }
  402. return &resp, nil
  403. }
  404. // Metadata returns metadata associated with the long-running operation.
  405. // Metadata itself does not contact the server, but Poll does.
  406. // To get the latest metadata, call this method after a successful call to Poll.
  407. // If the metadata is not available, the returned metadata and error are both nil.
  408. func (op *CreateDatabaseOperation) Metadata() (*databasepb.CreateDatabaseMetadata, error) {
  409. var meta databasepb.CreateDatabaseMetadata
  410. if err := op.lro.Metadata(&meta); err == longrunning.ErrNoMetadata {
  411. return nil, nil
  412. } else if err != nil {
  413. return nil, err
  414. }
  415. return &meta, nil
  416. }
  417. // Done reports whether the long-running operation has completed.
  418. func (op *CreateDatabaseOperation) Done() bool {
  419. return op.lro.Done()
  420. }
  421. // Name returns the name of the long-running operation.
  422. // The name is assigned by the server and is unique within the service from which the operation is created.
  423. func (op *CreateDatabaseOperation) Name() string {
  424. return op.lro.Name()
  425. }
  426. // UpdateDatabaseDdlOperation manages a long-running operation from UpdateDatabaseDdl.
  427. type UpdateDatabaseDdlOperation struct {
  428. lro *longrunning.Operation
  429. }
  430. // UpdateDatabaseDdlOperation returns a new UpdateDatabaseDdlOperation from a given name.
  431. // The name must be that of a previously created UpdateDatabaseDdlOperation, possibly from a different process.
  432. func (c *DatabaseAdminClient) UpdateDatabaseDdlOperation(name string) *UpdateDatabaseDdlOperation {
  433. return &UpdateDatabaseDdlOperation{
  434. lro: longrunning.InternalNewOperation(c.LROClient, &longrunningpb.Operation{Name: name}),
  435. }
  436. }
  437. // Wait blocks until the long-running operation is completed, returning any error encountered.
  438. //
  439. // See documentation of Poll for error-handling information.
  440. func (op *UpdateDatabaseDdlOperation) Wait(ctx context.Context, opts ...gax.CallOption) error {
  441. return op.lro.WaitWithInterval(ctx, nil, 45000*time.Millisecond, opts...)
  442. }
  443. // Poll fetches the latest state of the long-running operation.
  444. //
  445. // Poll also fetches the latest metadata, which can be retrieved by Metadata.
  446. //
  447. // If Poll fails, the error is returned and op is unmodified. If Poll succeeds and
  448. // the operation has completed with failure, the error is returned and op.Done will return true.
  449. // If Poll succeeds and the operation has completed successfully, op.Done will return true.
  450. func (op *UpdateDatabaseDdlOperation) Poll(ctx context.Context, opts ...gax.CallOption) error {
  451. return op.lro.Poll(ctx, nil, opts...)
  452. }
  453. // Metadata returns metadata associated with the long-running operation.
  454. // Metadata itself does not contact the server, but Poll does.
  455. // To get the latest metadata, call this method after a successful call to Poll.
  456. // If the metadata is not available, the returned metadata and error are both nil.
  457. func (op *UpdateDatabaseDdlOperation) Metadata() (*databasepb.UpdateDatabaseDdlMetadata, error) {
  458. var meta databasepb.UpdateDatabaseDdlMetadata
  459. if err := op.lro.Metadata(&meta); err == longrunning.ErrNoMetadata {
  460. return nil, nil
  461. } else if err != nil {
  462. return nil, err
  463. }
  464. return &meta, nil
  465. }
  466. // Done reports whether the long-running operation has completed.
  467. func (op *UpdateDatabaseDdlOperation) Done() bool {
  468. return op.lro.Done()
  469. }
  470. // Name returns the name of the long-running operation.
  471. // The name is assigned by the server and is unique within the service from which the operation is created.
  472. func (op *UpdateDatabaseDdlOperation) Name() string {
  473. return op.lro.Name()
  474. }