@googleapis/biglake 0.1.1 → 2.0.1
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/CHANGELOG.md +42 -0
- package/build/index.d.ts +1 -1
- package/build/index.js.map +1 -1
- package/build/v1.d.ts +950 -31
- package/build/v1.js.map +1 -1
- package/index.ts +0 -1
- package/package.json +2 -2
- package/v1.ts +1004 -49
package/build/v1.d.ts
CHANGED
|
@@ -1,5 +1,5 @@
|
|
|
1
1
|
/// <reference types="node" />
|
|
2
|
-
import { OAuth2Client, JWT, Compute, UserRefreshClient, BaseExternalAccountClient,
|
|
2
|
+
import { OAuth2Client, JWT, Compute, UserRefreshClient, BaseExternalAccountClient, GaxiosResponseWithHTTP2, GoogleConfigurable, MethodOptions, StreamMethodOptions, GlobalOptions, GoogleAuth, BodyResponseCallback, APIRequestContext } from 'googleapis-common';
|
|
3
3
|
import { Readable } from 'stream';
|
|
4
4
|
export declare namespace biglake_v1 {
|
|
5
5
|
export interface Options extends GlobalOptions {
|
|
@@ -294,56 +294,283 @@ export declare namespace biglake_v1 {
|
|
|
294
294
|
constructor(context: APIRequestContext);
|
|
295
295
|
/**
|
|
296
296
|
* Creates a new catalog.
|
|
297
|
+
* @example
|
|
298
|
+
* ```js
|
|
299
|
+
* // Before running the sample:
|
|
300
|
+
* // - Enable the API at:
|
|
301
|
+
* // https://console.developers.google.com/apis/api/biglake.googleapis.com
|
|
302
|
+
* // - Login into gcloud by running:
|
|
303
|
+
* // ```sh
|
|
304
|
+
* // $ gcloud auth application-default login
|
|
305
|
+
* // ```
|
|
306
|
+
* // - Install the npm module by running:
|
|
307
|
+
* // ```sh
|
|
308
|
+
* // $ npm install googleapis
|
|
309
|
+
* // ```
|
|
310
|
+
*
|
|
311
|
+
* const {google} = require('googleapis');
|
|
312
|
+
* const biglake = google.biglake('v1');
|
|
313
|
+
*
|
|
314
|
+
* async function main() {
|
|
315
|
+
* const auth = new google.auth.GoogleAuth({
|
|
316
|
+
* // Scopes can be specified either as an array or as a single, space-delimited string.
|
|
317
|
+
* scopes: [
|
|
318
|
+
* 'https://www.googleapis.com/auth/bigquery',
|
|
319
|
+
* 'https://www.googleapis.com/auth/cloud-platform',
|
|
320
|
+
* ],
|
|
321
|
+
* });
|
|
322
|
+
*
|
|
323
|
+
* // Acquire an auth client, and bind it to all future calls
|
|
324
|
+
* const authClient = await auth.getClient();
|
|
325
|
+
* google.options({auth: authClient});
|
|
326
|
+
*
|
|
327
|
+
* // Do the magic
|
|
328
|
+
* const res = await biglake.projects.locations.catalogs.create({
|
|
329
|
+
* // Required. The ID to use for the catalog, which will become the final component of the catalog's resource name.
|
|
330
|
+
* catalogId: 'placeholder-value',
|
|
331
|
+
* // Required. The parent resource where this catalog will be created. Format: projects/{project_id_or_number\}/locations/{location_id\}
|
|
332
|
+
* parent: 'projects/my-project/locations/my-location',
|
|
333
|
+
*
|
|
334
|
+
* // Request body metadata
|
|
335
|
+
* requestBody: {
|
|
336
|
+
* // request body parameters
|
|
337
|
+
* // {
|
|
338
|
+
* // "createTime": "my_createTime",
|
|
339
|
+
* // "deleteTime": "my_deleteTime",
|
|
340
|
+
* // "expireTime": "my_expireTime",
|
|
341
|
+
* // "name": "my_name",
|
|
342
|
+
* // "updateTime": "my_updateTime"
|
|
343
|
+
* // }
|
|
344
|
+
* },
|
|
345
|
+
* });
|
|
346
|
+
* console.log(res.data);
|
|
347
|
+
*
|
|
348
|
+
* // Example response
|
|
349
|
+
* // {
|
|
350
|
+
* // "createTime": "my_createTime",
|
|
351
|
+
* // "deleteTime": "my_deleteTime",
|
|
352
|
+
* // "expireTime": "my_expireTime",
|
|
353
|
+
* // "name": "my_name",
|
|
354
|
+
* // "updateTime": "my_updateTime"
|
|
355
|
+
* // }
|
|
356
|
+
* }
|
|
357
|
+
*
|
|
358
|
+
* main().catch(e => {
|
|
359
|
+
* console.error(e);
|
|
360
|
+
* throw e;
|
|
361
|
+
* });
|
|
362
|
+
*
|
|
363
|
+
* ```
|
|
297
364
|
*
|
|
298
365
|
* @param params - Parameters for request
|
|
299
366
|
* @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
|
|
300
367
|
* @param callback - Optional callback that handles the response.
|
|
301
368
|
* @returns A promise if used with async/await, or void if used with a callback.
|
|
302
369
|
*/
|
|
303
|
-
create(params: Params$Resource$Projects$Locations$Catalogs$Create, options: StreamMethodOptions):
|
|
304
|
-
create(params?: Params$Resource$Projects$Locations$Catalogs$Create, options?: MethodOptions):
|
|
370
|
+
create(params: Params$Resource$Projects$Locations$Catalogs$Create, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
|
|
371
|
+
create(params?: Params$Resource$Projects$Locations$Catalogs$Create, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$Catalog>>;
|
|
305
372
|
create(params: Params$Resource$Projects$Locations$Catalogs$Create, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
|
|
306
373
|
create(params: Params$Resource$Projects$Locations$Catalogs$Create, options: MethodOptions | BodyResponseCallback<Schema$Catalog>, callback: BodyResponseCallback<Schema$Catalog>): void;
|
|
307
374
|
create(params: Params$Resource$Projects$Locations$Catalogs$Create, callback: BodyResponseCallback<Schema$Catalog>): void;
|
|
308
375
|
create(callback: BodyResponseCallback<Schema$Catalog>): void;
|
|
309
376
|
/**
|
|
310
377
|
* Deletes an existing catalog specified by the catalog ID.
|
|
378
|
+
* @example
|
|
379
|
+
* ```js
|
|
380
|
+
* // Before running the sample:
|
|
381
|
+
* // - Enable the API at:
|
|
382
|
+
* // https://console.developers.google.com/apis/api/biglake.googleapis.com
|
|
383
|
+
* // - Login into gcloud by running:
|
|
384
|
+
* // ```sh
|
|
385
|
+
* // $ gcloud auth application-default login
|
|
386
|
+
* // ```
|
|
387
|
+
* // - Install the npm module by running:
|
|
388
|
+
* // ```sh
|
|
389
|
+
* // $ npm install googleapis
|
|
390
|
+
* // ```
|
|
391
|
+
*
|
|
392
|
+
* const {google} = require('googleapis');
|
|
393
|
+
* const biglake = google.biglake('v1');
|
|
394
|
+
*
|
|
395
|
+
* async function main() {
|
|
396
|
+
* const auth = new google.auth.GoogleAuth({
|
|
397
|
+
* // Scopes can be specified either as an array or as a single, space-delimited string.
|
|
398
|
+
* scopes: [
|
|
399
|
+
* 'https://www.googleapis.com/auth/bigquery',
|
|
400
|
+
* 'https://www.googleapis.com/auth/cloud-platform',
|
|
401
|
+
* ],
|
|
402
|
+
* });
|
|
403
|
+
*
|
|
404
|
+
* // Acquire an auth client, and bind it to all future calls
|
|
405
|
+
* const authClient = await auth.getClient();
|
|
406
|
+
* google.options({auth: authClient});
|
|
407
|
+
*
|
|
408
|
+
* // Do the magic
|
|
409
|
+
* const res = await biglake.projects.locations.catalogs.delete({
|
|
410
|
+
* // Required. The name of the catalog to delete. Format: projects/{project_id_or_number\}/locations/{location_id\}/catalogs/{catalog_id\}
|
|
411
|
+
* name: 'projects/my-project/locations/my-location/catalogs/my-catalog',
|
|
412
|
+
* });
|
|
413
|
+
* console.log(res.data);
|
|
414
|
+
*
|
|
415
|
+
* // Example response
|
|
416
|
+
* // {
|
|
417
|
+
* // "createTime": "my_createTime",
|
|
418
|
+
* // "deleteTime": "my_deleteTime",
|
|
419
|
+
* // "expireTime": "my_expireTime",
|
|
420
|
+
* // "name": "my_name",
|
|
421
|
+
* // "updateTime": "my_updateTime"
|
|
422
|
+
* // }
|
|
423
|
+
* }
|
|
424
|
+
*
|
|
425
|
+
* main().catch(e => {
|
|
426
|
+
* console.error(e);
|
|
427
|
+
* throw e;
|
|
428
|
+
* });
|
|
429
|
+
*
|
|
430
|
+
* ```
|
|
311
431
|
*
|
|
312
432
|
* @param params - Parameters for request
|
|
313
433
|
* @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
|
|
314
434
|
* @param callback - Optional callback that handles the response.
|
|
315
435
|
* @returns A promise if used with async/await, or void if used with a callback.
|
|
316
436
|
*/
|
|
317
|
-
delete(params: Params$Resource$Projects$Locations$Catalogs$Delete, options: StreamMethodOptions):
|
|
318
|
-
delete(params?: Params$Resource$Projects$Locations$Catalogs$Delete, options?: MethodOptions):
|
|
437
|
+
delete(params: Params$Resource$Projects$Locations$Catalogs$Delete, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
|
|
438
|
+
delete(params?: Params$Resource$Projects$Locations$Catalogs$Delete, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$Catalog>>;
|
|
319
439
|
delete(params: Params$Resource$Projects$Locations$Catalogs$Delete, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
|
|
320
440
|
delete(params: Params$Resource$Projects$Locations$Catalogs$Delete, options: MethodOptions | BodyResponseCallback<Schema$Catalog>, callback: BodyResponseCallback<Schema$Catalog>): void;
|
|
321
441
|
delete(params: Params$Resource$Projects$Locations$Catalogs$Delete, callback: BodyResponseCallback<Schema$Catalog>): void;
|
|
322
442
|
delete(callback: BodyResponseCallback<Schema$Catalog>): void;
|
|
323
443
|
/**
|
|
324
444
|
* Gets the catalog specified by the resource name.
|
|
445
|
+
* @example
|
|
446
|
+
* ```js
|
|
447
|
+
* // Before running the sample:
|
|
448
|
+
* // - Enable the API at:
|
|
449
|
+
* // https://console.developers.google.com/apis/api/biglake.googleapis.com
|
|
450
|
+
* // - Login into gcloud by running:
|
|
451
|
+
* // ```sh
|
|
452
|
+
* // $ gcloud auth application-default login
|
|
453
|
+
* // ```
|
|
454
|
+
* // - Install the npm module by running:
|
|
455
|
+
* // ```sh
|
|
456
|
+
* // $ npm install googleapis
|
|
457
|
+
* // ```
|
|
458
|
+
*
|
|
459
|
+
* const {google} = require('googleapis');
|
|
460
|
+
* const biglake = google.biglake('v1');
|
|
461
|
+
*
|
|
462
|
+
* async function main() {
|
|
463
|
+
* const auth = new google.auth.GoogleAuth({
|
|
464
|
+
* // Scopes can be specified either as an array or as a single, space-delimited string.
|
|
465
|
+
* scopes: [
|
|
466
|
+
* 'https://www.googleapis.com/auth/bigquery',
|
|
467
|
+
* 'https://www.googleapis.com/auth/cloud-platform',
|
|
468
|
+
* ],
|
|
469
|
+
* });
|
|
470
|
+
*
|
|
471
|
+
* // Acquire an auth client, and bind it to all future calls
|
|
472
|
+
* const authClient = await auth.getClient();
|
|
473
|
+
* google.options({auth: authClient});
|
|
474
|
+
*
|
|
475
|
+
* // Do the magic
|
|
476
|
+
* const res = await biglake.projects.locations.catalogs.get({
|
|
477
|
+
* // Required. The name of the catalog to retrieve. Format: projects/{project_id_or_number\}/locations/{location_id\}/catalogs/{catalog_id\}
|
|
478
|
+
* name: 'projects/my-project/locations/my-location/catalogs/my-catalog',
|
|
479
|
+
* });
|
|
480
|
+
* console.log(res.data);
|
|
481
|
+
*
|
|
482
|
+
* // Example response
|
|
483
|
+
* // {
|
|
484
|
+
* // "createTime": "my_createTime",
|
|
485
|
+
* // "deleteTime": "my_deleteTime",
|
|
486
|
+
* // "expireTime": "my_expireTime",
|
|
487
|
+
* // "name": "my_name",
|
|
488
|
+
* // "updateTime": "my_updateTime"
|
|
489
|
+
* // }
|
|
490
|
+
* }
|
|
491
|
+
*
|
|
492
|
+
* main().catch(e => {
|
|
493
|
+
* console.error(e);
|
|
494
|
+
* throw e;
|
|
495
|
+
* });
|
|
496
|
+
*
|
|
497
|
+
* ```
|
|
325
498
|
*
|
|
326
499
|
* @param params - Parameters for request
|
|
327
500
|
* @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
|
|
328
501
|
* @param callback - Optional callback that handles the response.
|
|
329
502
|
* @returns A promise if used with async/await, or void if used with a callback.
|
|
330
503
|
*/
|
|
331
|
-
get(params: Params$Resource$Projects$Locations$Catalogs$Get, options: StreamMethodOptions):
|
|
332
|
-
get(params?: Params$Resource$Projects$Locations$Catalogs$Get, options?: MethodOptions):
|
|
504
|
+
get(params: Params$Resource$Projects$Locations$Catalogs$Get, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
|
|
505
|
+
get(params?: Params$Resource$Projects$Locations$Catalogs$Get, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$Catalog>>;
|
|
333
506
|
get(params: Params$Resource$Projects$Locations$Catalogs$Get, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
|
|
334
507
|
get(params: Params$Resource$Projects$Locations$Catalogs$Get, options: MethodOptions | BodyResponseCallback<Schema$Catalog>, callback: BodyResponseCallback<Schema$Catalog>): void;
|
|
335
508
|
get(params: Params$Resource$Projects$Locations$Catalogs$Get, callback: BodyResponseCallback<Schema$Catalog>): void;
|
|
336
509
|
get(callback: BodyResponseCallback<Schema$Catalog>): void;
|
|
337
510
|
/**
|
|
338
511
|
* List all catalogs in a specified project.
|
|
512
|
+
* @example
|
|
513
|
+
* ```js
|
|
514
|
+
* // Before running the sample:
|
|
515
|
+
* // - Enable the API at:
|
|
516
|
+
* // https://console.developers.google.com/apis/api/biglake.googleapis.com
|
|
517
|
+
* // - Login into gcloud by running:
|
|
518
|
+
* // ```sh
|
|
519
|
+
* // $ gcloud auth application-default login
|
|
520
|
+
* // ```
|
|
521
|
+
* // - Install the npm module by running:
|
|
522
|
+
* // ```sh
|
|
523
|
+
* // $ npm install googleapis
|
|
524
|
+
* // ```
|
|
525
|
+
*
|
|
526
|
+
* const {google} = require('googleapis');
|
|
527
|
+
* const biglake = google.biglake('v1');
|
|
528
|
+
*
|
|
529
|
+
* async function main() {
|
|
530
|
+
* const auth = new google.auth.GoogleAuth({
|
|
531
|
+
* // Scopes can be specified either as an array or as a single, space-delimited string.
|
|
532
|
+
* scopes: [
|
|
533
|
+
* 'https://www.googleapis.com/auth/bigquery',
|
|
534
|
+
* 'https://www.googleapis.com/auth/cloud-platform',
|
|
535
|
+
* ],
|
|
536
|
+
* });
|
|
537
|
+
*
|
|
538
|
+
* // Acquire an auth client, and bind it to all future calls
|
|
539
|
+
* const authClient = await auth.getClient();
|
|
540
|
+
* google.options({auth: authClient});
|
|
541
|
+
*
|
|
542
|
+
* // Do the magic
|
|
543
|
+
* const res = await biglake.projects.locations.catalogs.list({
|
|
544
|
+
* // The maximum number of catalogs to return. The service may return fewer than this value. If unspecified, at most 50 catalogs will be returned. The maximum value is 1000; values above 1000 will be coerced to 1000.
|
|
545
|
+
* pageSize: 'placeholder-value',
|
|
546
|
+
* // A page token, received from a previous `ListCatalogs` call. Provide this to retrieve the subsequent page. When paginating, all other parameters provided to `ListCatalogs` must match the call that provided the page token.
|
|
547
|
+
* pageToken: 'placeholder-value',
|
|
548
|
+
* // Required. The parent, which owns this collection of catalogs. Format: projects/{project_id_or_number\}/locations/{location_id\}
|
|
549
|
+
* parent: 'projects/my-project/locations/my-location',
|
|
550
|
+
* });
|
|
551
|
+
* console.log(res.data);
|
|
552
|
+
*
|
|
553
|
+
* // Example response
|
|
554
|
+
* // {
|
|
555
|
+
* // "catalogs": [],
|
|
556
|
+
* // "nextPageToken": "my_nextPageToken"
|
|
557
|
+
* // }
|
|
558
|
+
* }
|
|
559
|
+
*
|
|
560
|
+
* main().catch(e => {
|
|
561
|
+
* console.error(e);
|
|
562
|
+
* throw e;
|
|
563
|
+
* });
|
|
564
|
+
*
|
|
565
|
+
* ```
|
|
339
566
|
*
|
|
340
567
|
* @param params - Parameters for request
|
|
341
568
|
* @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
|
|
342
569
|
* @param callback - Optional callback that handles the response.
|
|
343
570
|
* @returns A promise if used with async/await, or void if used with a callback.
|
|
344
571
|
*/
|
|
345
|
-
list(params: Params$Resource$Projects$Locations$Catalogs$List, options: StreamMethodOptions):
|
|
346
|
-
list(params?: Params$Resource$Projects$Locations$Catalogs$List, options?: MethodOptions):
|
|
572
|
+
list(params: Params$Resource$Projects$Locations$Catalogs$List, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
|
|
573
|
+
list(params?: Params$Resource$Projects$Locations$Catalogs$List, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$ListCatalogsResponse>>;
|
|
347
574
|
list(params: Params$Resource$Projects$Locations$Catalogs$List, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
|
|
348
575
|
list(params: Params$Resource$Projects$Locations$Catalogs$List, options: MethodOptions | BodyResponseCallback<Schema$ListCatalogsResponse>, callback: BodyResponseCallback<Schema$ListCatalogsResponse>): void;
|
|
349
576
|
list(params: Params$Resource$Projects$Locations$Catalogs$List, callback: BodyResponseCallback<Schema$ListCatalogsResponse>): void;
|
|
@@ -395,70 +622,376 @@ export declare namespace biglake_v1 {
|
|
|
395
622
|
constructor(context: APIRequestContext);
|
|
396
623
|
/**
|
|
397
624
|
* Creates a new database.
|
|
625
|
+
* @example
|
|
626
|
+
* ```js
|
|
627
|
+
* // Before running the sample:
|
|
628
|
+
* // - Enable the API at:
|
|
629
|
+
* // https://console.developers.google.com/apis/api/biglake.googleapis.com
|
|
630
|
+
* // - Login into gcloud by running:
|
|
631
|
+
* // ```sh
|
|
632
|
+
* // $ gcloud auth application-default login
|
|
633
|
+
* // ```
|
|
634
|
+
* // - Install the npm module by running:
|
|
635
|
+
* // ```sh
|
|
636
|
+
* // $ npm install googleapis
|
|
637
|
+
* // ```
|
|
638
|
+
*
|
|
639
|
+
* const {google} = require('googleapis');
|
|
640
|
+
* const biglake = google.biglake('v1');
|
|
641
|
+
*
|
|
642
|
+
* async function main() {
|
|
643
|
+
* const auth = new google.auth.GoogleAuth({
|
|
644
|
+
* // Scopes can be specified either as an array or as a single, space-delimited string.
|
|
645
|
+
* scopes: [
|
|
646
|
+
* 'https://www.googleapis.com/auth/bigquery',
|
|
647
|
+
* 'https://www.googleapis.com/auth/cloud-platform',
|
|
648
|
+
* ],
|
|
649
|
+
* });
|
|
650
|
+
*
|
|
651
|
+
* // Acquire an auth client, and bind it to all future calls
|
|
652
|
+
* const authClient = await auth.getClient();
|
|
653
|
+
* google.options({auth: authClient});
|
|
654
|
+
*
|
|
655
|
+
* // Do the magic
|
|
656
|
+
* const res = await biglake.projects.locations.catalogs.databases.create({
|
|
657
|
+
* // Required. The ID to use for the database, which will become the final component of the database's resource name.
|
|
658
|
+
* databaseId: 'placeholder-value',
|
|
659
|
+
* // Required. The parent resource where this database will be created. Format: projects/{project_id_or_number\}/locations/{location_id\}/catalogs/{catalog_id\}
|
|
660
|
+
* parent: 'projects/my-project/locations/my-location/catalogs/my-catalog',
|
|
661
|
+
*
|
|
662
|
+
* // Request body metadata
|
|
663
|
+
* requestBody: {
|
|
664
|
+
* // request body parameters
|
|
665
|
+
* // {
|
|
666
|
+
* // "createTime": "my_createTime",
|
|
667
|
+
* // "deleteTime": "my_deleteTime",
|
|
668
|
+
* // "expireTime": "my_expireTime",
|
|
669
|
+
* // "hiveOptions": {},
|
|
670
|
+
* // "name": "my_name",
|
|
671
|
+
* // "type": "my_type",
|
|
672
|
+
* // "updateTime": "my_updateTime"
|
|
673
|
+
* // }
|
|
674
|
+
* },
|
|
675
|
+
* });
|
|
676
|
+
* console.log(res.data);
|
|
677
|
+
*
|
|
678
|
+
* // Example response
|
|
679
|
+
* // {
|
|
680
|
+
* // "createTime": "my_createTime",
|
|
681
|
+
* // "deleteTime": "my_deleteTime",
|
|
682
|
+
* // "expireTime": "my_expireTime",
|
|
683
|
+
* // "hiveOptions": {},
|
|
684
|
+
* // "name": "my_name",
|
|
685
|
+
* // "type": "my_type",
|
|
686
|
+
* // "updateTime": "my_updateTime"
|
|
687
|
+
* // }
|
|
688
|
+
* }
|
|
689
|
+
*
|
|
690
|
+
* main().catch(e => {
|
|
691
|
+
* console.error(e);
|
|
692
|
+
* throw e;
|
|
693
|
+
* });
|
|
694
|
+
*
|
|
695
|
+
* ```
|
|
398
696
|
*
|
|
399
697
|
* @param params - Parameters for request
|
|
400
698
|
* @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
|
|
401
699
|
* @param callback - Optional callback that handles the response.
|
|
402
700
|
* @returns A promise if used with async/await, or void if used with a callback.
|
|
403
701
|
*/
|
|
404
|
-
create(params: Params$Resource$Projects$Locations$Catalogs$Databases$Create, options: StreamMethodOptions):
|
|
405
|
-
create(params?: Params$Resource$Projects$Locations$Catalogs$Databases$Create, options?: MethodOptions):
|
|
702
|
+
create(params: Params$Resource$Projects$Locations$Catalogs$Databases$Create, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
|
|
703
|
+
create(params?: Params$Resource$Projects$Locations$Catalogs$Databases$Create, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$Database>>;
|
|
406
704
|
create(params: Params$Resource$Projects$Locations$Catalogs$Databases$Create, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
|
|
407
705
|
create(params: Params$Resource$Projects$Locations$Catalogs$Databases$Create, options: MethodOptions | BodyResponseCallback<Schema$Database>, callback: BodyResponseCallback<Schema$Database>): void;
|
|
408
706
|
create(params: Params$Resource$Projects$Locations$Catalogs$Databases$Create, callback: BodyResponseCallback<Schema$Database>): void;
|
|
409
707
|
create(callback: BodyResponseCallback<Schema$Database>): void;
|
|
410
708
|
/**
|
|
411
709
|
* Deletes an existing database specified by the database ID.
|
|
710
|
+
* @example
|
|
711
|
+
* ```js
|
|
712
|
+
* // Before running the sample:
|
|
713
|
+
* // - Enable the API at:
|
|
714
|
+
* // https://console.developers.google.com/apis/api/biglake.googleapis.com
|
|
715
|
+
* // - Login into gcloud by running:
|
|
716
|
+
* // ```sh
|
|
717
|
+
* // $ gcloud auth application-default login
|
|
718
|
+
* // ```
|
|
719
|
+
* // - Install the npm module by running:
|
|
720
|
+
* // ```sh
|
|
721
|
+
* // $ npm install googleapis
|
|
722
|
+
* // ```
|
|
723
|
+
*
|
|
724
|
+
* const {google} = require('googleapis');
|
|
725
|
+
* const biglake = google.biglake('v1');
|
|
726
|
+
*
|
|
727
|
+
* async function main() {
|
|
728
|
+
* const auth = new google.auth.GoogleAuth({
|
|
729
|
+
* // Scopes can be specified either as an array or as a single, space-delimited string.
|
|
730
|
+
* scopes: [
|
|
731
|
+
* 'https://www.googleapis.com/auth/bigquery',
|
|
732
|
+
* 'https://www.googleapis.com/auth/cloud-platform',
|
|
733
|
+
* ],
|
|
734
|
+
* });
|
|
735
|
+
*
|
|
736
|
+
* // Acquire an auth client, and bind it to all future calls
|
|
737
|
+
* const authClient = await auth.getClient();
|
|
738
|
+
* google.options({auth: authClient});
|
|
739
|
+
*
|
|
740
|
+
* // Do the magic
|
|
741
|
+
* const res = await biglake.projects.locations.catalogs.databases.delete({
|
|
742
|
+
* // Required. The name of the database to delete. Format: projects/{project_id_or_number\}/locations/{location_id\}/catalogs/{catalog_id\}/databases/{database_id\}
|
|
743
|
+
* name: 'projects/my-project/locations/my-location/catalogs/my-catalog/databases/my-database',
|
|
744
|
+
* });
|
|
745
|
+
* console.log(res.data);
|
|
746
|
+
*
|
|
747
|
+
* // Example response
|
|
748
|
+
* // {
|
|
749
|
+
* // "createTime": "my_createTime",
|
|
750
|
+
* // "deleteTime": "my_deleteTime",
|
|
751
|
+
* // "expireTime": "my_expireTime",
|
|
752
|
+
* // "hiveOptions": {},
|
|
753
|
+
* // "name": "my_name",
|
|
754
|
+
* // "type": "my_type",
|
|
755
|
+
* // "updateTime": "my_updateTime"
|
|
756
|
+
* // }
|
|
757
|
+
* }
|
|
758
|
+
*
|
|
759
|
+
* main().catch(e => {
|
|
760
|
+
* console.error(e);
|
|
761
|
+
* throw e;
|
|
762
|
+
* });
|
|
763
|
+
*
|
|
764
|
+
* ```
|
|
412
765
|
*
|
|
413
766
|
* @param params - Parameters for request
|
|
414
767
|
* @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
|
|
415
768
|
* @param callback - Optional callback that handles the response.
|
|
416
769
|
* @returns A promise if used with async/await, or void if used with a callback.
|
|
417
770
|
*/
|
|
418
|
-
delete(params: Params$Resource$Projects$Locations$Catalogs$Databases$Delete, options: StreamMethodOptions):
|
|
419
|
-
delete(params?: Params$Resource$Projects$Locations$Catalogs$Databases$Delete, options?: MethodOptions):
|
|
771
|
+
delete(params: Params$Resource$Projects$Locations$Catalogs$Databases$Delete, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
|
|
772
|
+
delete(params?: Params$Resource$Projects$Locations$Catalogs$Databases$Delete, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$Database>>;
|
|
420
773
|
delete(params: Params$Resource$Projects$Locations$Catalogs$Databases$Delete, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
|
|
421
774
|
delete(params: Params$Resource$Projects$Locations$Catalogs$Databases$Delete, options: MethodOptions | BodyResponseCallback<Schema$Database>, callback: BodyResponseCallback<Schema$Database>): void;
|
|
422
775
|
delete(params: Params$Resource$Projects$Locations$Catalogs$Databases$Delete, callback: BodyResponseCallback<Schema$Database>): void;
|
|
423
776
|
delete(callback: BodyResponseCallback<Schema$Database>): void;
|
|
424
777
|
/**
|
|
425
778
|
* Gets the database specified by the resource name.
|
|
779
|
+
* @example
|
|
780
|
+
* ```js
|
|
781
|
+
* // Before running the sample:
|
|
782
|
+
* // - Enable the API at:
|
|
783
|
+
* // https://console.developers.google.com/apis/api/biglake.googleapis.com
|
|
784
|
+
* // - Login into gcloud by running:
|
|
785
|
+
* // ```sh
|
|
786
|
+
* // $ gcloud auth application-default login
|
|
787
|
+
* // ```
|
|
788
|
+
* // - Install the npm module by running:
|
|
789
|
+
* // ```sh
|
|
790
|
+
* // $ npm install googleapis
|
|
791
|
+
* // ```
|
|
792
|
+
*
|
|
793
|
+
* const {google} = require('googleapis');
|
|
794
|
+
* const biglake = google.biglake('v1');
|
|
795
|
+
*
|
|
796
|
+
* async function main() {
|
|
797
|
+
* const auth = new google.auth.GoogleAuth({
|
|
798
|
+
* // Scopes can be specified either as an array or as a single, space-delimited string.
|
|
799
|
+
* scopes: [
|
|
800
|
+
* 'https://www.googleapis.com/auth/bigquery',
|
|
801
|
+
* 'https://www.googleapis.com/auth/cloud-platform',
|
|
802
|
+
* ],
|
|
803
|
+
* });
|
|
804
|
+
*
|
|
805
|
+
* // Acquire an auth client, and bind it to all future calls
|
|
806
|
+
* const authClient = await auth.getClient();
|
|
807
|
+
* google.options({auth: authClient});
|
|
808
|
+
*
|
|
809
|
+
* // Do the magic
|
|
810
|
+
* const res = await biglake.projects.locations.catalogs.databases.get({
|
|
811
|
+
* // Required. The name of the database to retrieve. Format: projects/{project_id_or_number\}/locations/{location_id\}/catalogs/{catalog_id\}/databases/{database_id\}
|
|
812
|
+
* name: 'projects/my-project/locations/my-location/catalogs/my-catalog/databases/my-database',
|
|
813
|
+
* });
|
|
814
|
+
* console.log(res.data);
|
|
815
|
+
*
|
|
816
|
+
* // Example response
|
|
817
|
+
* // {
|
|
818
|
+
* // "createTime": "my_createTime",
|
|
819
|
+
* // "deleteTime": "my_deleteTime",
|
|
820
|
+
* // "expireTime": "my_expireTime",
|
|
821
|
+
* // "hiveOptions": {},
|
|
822
|
+
* // "name": "my_name",
|
|
823
|
+
* // "type": "my_type",
|
|
824
|
+
* // "updateTime": "my_updateTime"
|
|
825
|
+
* // }
|
|
826
|
+
* }
|
|
827
|
+
*
|
|
828
|
+
* main().catch(e => {
|
|
829
|
+
* console.error(e);
|
|
830
|
+
* throw e;
|
|
831
|
+
* });
|
|
832
|
+
*
|
|
833
|
+
* ```
|
|
426
834
|
*
|
|
427
835
|
* @param params - Parameters for request
|
|
428
836
|
* @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
|
|
429
837
|
* @param callback - Optional callback that handles the response.
|
|
430
838
|
* @returns A promise if used with async/await, or void if used with a callback.
|
|
431
839
|
*/
|
|
432
|
-
get(params: Params$Resource$Projects$Locations$Catalogs$Databases$Get, options: StreamMethodOptions):
|
|
433
|
-
get(params?: Params$Resource$Projects$Locations$Catalogs$Databases$Get, options?: MethodOptions):
|
|
840
|
+
get(params: Params$Resource$Projects$Locations$Catalogs$Databases$Get, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
|
|
841
|
+
get(params?: Params$Resource$Projects$Locations$Catalogs$Databases$Get, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$Database>>;
|
|
434
842
|
get(params: Params$Resource$Projects$Locations$Catalogs$Databases$Get, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
|
|
435
843
|
get(params: Params$Resource$Projects$Locations$Catalogs$Databases$Get, options: MethodOptions | BodyResponseCallback<Schema$Database>, callback: BodyResponseCallback<Schema$Database>): void;
|
|
436
844
|
get(params: Params$Resource$Projects$Locations$Catalogs$Databases$Get, callback: BodyResponseCallback<Schema$Database>): void;
|
|
437
845
|
get(callback: BodyResponseCallback<Schema$Database>): void;
|
|
438
846
|
/**
|
|
439
847
|
* List all databases in a specified catalog.
|
|
848
|
+
* @example
|
|
849
|
+
* ```js
|
|
850
|
+
* // Before running the sample:
|
|
851
|
+
* // - Enable the API at:
|
|
852
|
+
* // https://console.developers.google.com/apis/api/biglake.googleapis.com
|
|
853
|
+
* // - Login into gcloud by running:
|
|
854
|
+
* // ```sh
|
|
855
|
+
* // $ gcloud auth application-default login
|
|
856
|
+
* // ```
|
|
857
|
+
* // - Install the npm module by running:
|
|
858
|
+
* // ```sh
|
|
859
|
+
* // $ npm install googleapis
|
|
860
|
+
* // ```
|
|
861
|
+
*
|
|
862
|
+
* const {google} = require('googleapis');
|
|
863
|
+
* const biglake = google.biglake('v1');
|
|
864
|
+
*
|
|
865
|
+
* async function main() {
|
|
866
|
+
* const auth = new google.auth.GoogleAuth({
|
|
867
|
+
* // Scopes can be specified either as an array or as a single, space-delimited string.
|
|
868
|
+
* scopes: [
|
|
869
|
+
* 'https://www.googleapis.com/auth/bigquery',
|
|
870
|
+
* 'https://www.googleapis.com/auth/cloud-platform',
|
|
871
|
+
* ],
|
|
872
|
+
* });
|
|
873
|
+
*
|
|
874
|
+
* // Acquire an auth client, and bind it to all future calls
|
|
875
|
+
* const authClient = await auth.getClient();
|
|
876
|
+
* google.options({auth: authClient});
|
|
877
|
+
*
|
|
878
|
+
* // Do the magic
|
|
879
|
+
* const res = await biglake.projects.locations.catalogs.databases.list({
|
|
880
|
+
* // The maximum number of databases to return. The service may return fewer than this value. If unspecified, at most 50 databases will be returned. The maximum value is 1000; values above 1000 will be coerced to 1000.
|
|
881
|
+
* pageSize: 'placeholder-value',
|
|
882
|
+
* // A page token, received from a previous `ListDatabases` call. Provide this to retrieve the subsequent page. When paginating, all other parameters provided to `ListDatabases` must match the call that provided the page token.
|
|
883
|
+
* pageToken: 'placeholder-value',
|
|
884
|
+
* // Required. The parent, which owns this collection of databases. Format: projects/{project_id_or_number\}/locations/{location_id\}/catalogs/{catalog_id\}
|
|
885
|
+
* parent: 'projects/my-project/locations/my-location/catalogs/my-catalog',
|
|
886
|
+
* });
|
|
887
|
+
* console.log(res.data);
|
|
888
|
+
*
|
|
889
|
+
* // Example response
|
|
890
|
+
* // {
|
|
891
|
+
* // "databases": [],
|
|
892
|
+
* // "nextPageToken": "my_nextPageToken"
|
|
893
|
+
* // }
|
|
894
|
+
* }
|
|
895
|
+
*
|
|
896
|
+
* main().catch(e => {
|
|
897
|
+
* console.error(e);
|
|
898
|
+
* throw e;
|
|
899
|
+
* });
|
|
900
|
+
*
|
|
901
|
+
* ```
|
|
440
902
|
*
|
|
441
903
|
* @param params - Parameters for request
|
|
442
904
|
* @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
|
|
443
905
|
* @param callback - Optional callback that handles the response.
|
|
444
906
|
* @returns A promise if used with async/await, or void if used with a callback.
|
|
445
907
|
*/
|
|
446
|
-
list(params: Params$Resource$Projects$Locations$Catalogs$Databases$List, options: StreamMethodOptions):
|
|
447
|
-
list(params?: Params$Resource$Projects$Locations$Catalogs$Databases$List, options?: MethodOptions):
|
|
908
|
+
list(params: Params$Resource$Projects$Locations$Catalogs$Databases$List, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
|
|
909
|
+
list(params?: Params$Resource$Projects$Locations$Catalogs$Databases$List, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$ListDatabasesResponse>>;
|
|
448
910
|
list(params: Params$Resource$Projects$Locations$Catalogs$Databases$List, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
|
|
449
911
|
list(params: Params$Resource$Projects$Locations$Catalogs$Databases$List, options: MethodOptions | BodyResponseCallback<Schema$ListDatabasesResponse>, callback: BodyResponseCallback<Schema$ListDatabasesResponse>): void;
|
|
450
912
|
list(params: Params$Resource$Projects$Locations$Catalogs$Databases$List, callback: BodyResponseCallback<Schema$ListDatabasesResponse>): void;
|
|
451
913
|
list(callback: BodyResponseCallback<Schema$ListDatabasesResponse>): void;
|
|
452
914
|
/**
|
|
453
915
|
* Updates an existing database specified by the database ID.
|
|
916
|
+
* @example
|
|
917
|
+
* ```js
|
|
918
|
+
* // Before running the sample:
|
|
919
|
+
* // - Enable the API at:
|
|
920
|
+
* // https://console.developers.google.com/apis/api/biglake.googleapis.com
|
|
921
|
+
* // - Login into gcloud by running:
|
|
922
|
+
* // ```sh
|
|
923
|
+
* // $ gcloud auth application-default login
|
|
924
|
+
* // ```
|
|
925
|
+
* // - Install the npm module by running:
|
|
926
|
+
* // ```sh
|
|
927
|
+
* // $ npm install googleapis
|
|
928
|
+
* // ```
|
|
929
|
+
*
|
|
930
|
+
* const {google} = require('googleapis');
|
|
931
|
+
* const biglake = google.biglake('v1');
|
|
932
|
+
*
|
|
933
|
+
* async function main() {
|
|
934
|
+
* const auth = new google.auth.GoogleAuth({
|
|
935
|
+
* // Scopes can be specified either as an array or as a single, space-delimited string.
|
|
936
|
+
* scopes: [
|
|
937
|
+
* 'https://www.googleapis.com/auth/bigquery',
|
|
938
|
+
* 'https://www.googleapis.com/auth/cloud-platform',
|
|
939
|
+
* ],
|
|
940
|
+
* });
|
|
941
|
+
*
|
|
942
|
+
* // Acquire an auth client, and bind it to all future calls
|
|
943
|
+
* const authClient = await auth.getClient();
|
|
944
|
+
* google.options({auth: authClient});
|
|
945
|
+
*
|
|
946
|
+
* // Do the magic
|
|
947
|
+
* const res = await biglake.projects.locations.catalogs.databases.patch({
|
|
948
|
+
* // Output only. The resource name. Format: projects/{project_id_or_number\}/locations/{location_id\}/catalogs/{catalog_id\}/databases/{database_id\}
|
|
949
|
+
* name: 'projects/my-project/locations/my-location/catalogs/my-catalog/databases/my-database',
|
|
950
|
+
* // The list of fields to update. For the `FieldMask` definition, see https://developers.google.com/protocol-buffers/docs/reference/google.protobuf#fieldmask If not set, defaults to all of the fields that are allowed to update.
|
|
951
|
+
* updateMask: 'placeholder-value',
|
|
952
|
+
*
|
|
953
|
+
* // Request body metadata
|
|
954
|
+
* requestBody: {
|
|
955
|
+
* // request body parameters
|
|
956
|
+
* // {
|
|
957
|
+
* // "createTime": "my_createTime",
|
|
958
|
+
* // "deleteTime": "my_deleteTime",
|
|
959
|
+
* // "expireTime": "my_expireTime",
|
|
960
|
+
* // "hiveOptions": {},
|
|
961
|
+
* // "name": "my_name",
|
|
962
|
+
* // "type": "my_type",
|
|
963
|
+
* // "updateTime": "my_updateTime"
|
|
964
|
+
* // }
|
|
965
|
+
* },
|
|
966
|
+
* });
|
|
967
|
+
* console.log(res.data);
|
|
968
|
+
*
|
|
969
|
+
* // Example response
|
|
970
|
+
* // {
|
|
971
|
+
* // "createTime": "my_createTime",
|
|
972
|
+
* // "deleteTime": "my_deleteTime",
|
|
973
|
+
* // "expireTime": "my_expireTime",
|
|
974
|
+
* // "hiveOptions": {},
|
|
975
|
+
* // "name": "my_name",
|
|
976
|
+
* // "type": "my_type",
|
|
977
|
+
* // "updateTime": "my_updateTime"
|
|
978
|
+
* // }
|
|
979
|
+
* }
|
|
980
|
+
*
|
|
981
|
+
* main().catch(e => {
|
|
982
|
+
* console.error(e);
|
|
983
|
+
* throw e;
|
|
984
|
+
* });
|
|
985
|
+
*
|
|
986
|
+
* ```
|
|
454
987
|
*
|
|
455
988
|
* @param params - Parameters for request
|
|
456
989
|
* @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
|
|
457
990
|
* @param callback - Optional callback that handles the response.
|
|
458
991
|
* @returns A promise if used with async/await, or void if used with a callback.
|
|
459
992
|
*/
|
|
460
|
-
patch(params: Params$Resource$Projects$Locations$Catalogs$Databases$Patch, options: StreamMethodOptions):
|
|
461
|
-
patch(params?: Params$Resource$Projects$Locations$Catalogs$Databases$Patch, options?: MethodOptions):
|
|
993
|
+
patch(params: Params$Resource$Projects$Locations$Catalogs$Databases$Patch, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
|
|
994
|
+
patch(params?: Params$Resource$Projects$Locations$Catalogs$Databases$Patch, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$Database>>;
|
|
462
995
|
patch(params: Params$Resource$Projects$Locations$Catalogs$Databases$Patch, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
|
|
463
996
|
patch(params: Params$Resource$Projects$Locations$Catalogs$Databases$Patch, options: MethodOptions | BodyResponseCallback<Schema$Database>, callback: BodyResponseCallback<Schema$Database>): void;
|
|
464
997
|
patch(params: Params$Resource$Projects$Locations$Catalogs$Databases$Patch, callback: BodyResponseCallback<Schema$Database>): void;
|
|
@@ -523,84 +1056,470 @@ export declare namespace biglake_v1 {
|
|
|
523
1056
|
constructor(context: APIRequestContext);
|
|
524
1057
|
/**
|
|
525
1058
|
* Creates a new table.
|
|
1059
|
+
* @example
|
|
1060
|
+
* ```js
|
|
1061
|
+
* // Before running the sample:
|
|
1062
|
+
* // - Enable the API at:
|
|
1063
|
+
* // https://console.developers.google.com/apis/api/biglake.googleapis.com
|
|
1064
|
+
* // - Login into gcloud by running:
|
|
1065
|
+
* // ```sh
|
|
1066
|
+
* // $ gcloud auth application-default login
|
|
1067
|
+
* // ```
|
|
1068
|
+
* // - Install the npm module by running:
|
|
1069
|
+
* // ```sh
|
|
1070
|
+
* // $ npm install googleapis
|
|
1071
|
+
* // ```
|
|
1072
|
+
*
|
|
1073
|
+
* const {google} = require('googleapis');
|
|
1074
|
+
* const biglake = google.biglake('v1');
|
|
1075
|
+
*
|
|
1076
|
+
* async function main() {
|
|
1077
|
+
* const auth = new google.auth.GoogleAuth({
|
|
1078
|
+
* // Scopes can be specified either as an array or as a single, space-delimited string.
|
|
1079
|
+
* scopes: [
|
|
1080
|
+
* 'https://www.googleapis.com/auth/bigquery',
|
|
1081
|
+
* 'https://www.googleapis.com/auth/cloud-platform',
|
|
1082
|
+
* ],
|
|
1083
|
+
* });
|
|
1084
|
+
*
|
|
1085
|
+
* // Acquire an auth client, and bind it to all future calls
|
|
1086
|
+
* const authClient = await auth.getClient();
|
|
1087
|
+
* google.options({auth: authClient});
|
|
1088
|
+
*
|
|
1089
|
+
* // Do the magic
|
|
1090
|
+
* const res = await biglake.projects.locations.catalogs.databases.tables.create(
|
|
1091
|
+
* {
|
|
1092
|
+
* // Required. The parent resource where this table will be created. Format: projects/{project_id_or_number\}/locations/{location_id\}/catalogs/{catalog_id\}/databases/{database_id\}
|
|
1093
|
+
* parent:
|
|
1094
|
+
* 'projects/my-project/locations/my-location/catalogs/my-catalog/databases/my-database',
|
|
1095
|
+
* // Required. The ID to use for the table, which will become the final component of the table's resource name.
|
|
1096
|
+
* tableId: 'placeholder-value',
|
|
1097
|
+
*
|
|
1098
|
+
* // Request body metadata
|
|
1099
|
+
* requestBody: {
|
|
1100
|
+
* // request body parameters
|
|
1101
|
+
* // {
|
|
1102
|
+
* // "createTime": "my_createTime",
|
|
1103
|
+
* // "deleteTime": "my_deleteTime",
|
|
1104
|
+
* // "etag": "my_etag",
|
|
1105
|
+
* // "expireTime": "my_expireTime",
|
|
1106
|
+
* // "hiveOptions": {},
|
|
1107
|
+
* // "name": "my_name",
|
|
1108
|
+
* // "type": "my_type",
|
|
1109
|
+
* // "updateTime": "my_updateTime"
|
|
1110
|
+
* // }
|
|
1111
|
+
* },
|
|
1112
|
+
* },
|
|
1113
|
+
* );
|
|
1114
|
+
* console.log(res.data);
|
|
1115
|
+
*
|
|
1116
|
+
* // Example response
|
|
1117
|
+
* // {
|
|
1118
|
+
* // "createTime": "my_createTime",
|
|
1119
|
+
* // "deleteTime": "my_deleteTime",
|
|
1120
|
+
* // "etag": "my_etag",
|
|
1121
|
+
* // "expireTime": "my_expireTime",
|
|
1122
|
+
* // "hiveOptions": {},
|
|
1123
|
+
* // "name": "my_name",
|
|
1124
|
+
* // "type": "my_type",
|
|
1125
|
+
* // "updateTime": "my_updateTime"
|
|
1126
|
+
* // }
|
|
1127
|
+
* }
|
|
1128
|
+
*
|
|
1129
|
+
* main().catch(e => {
|
|
1130
|
+
* console.error(e);
|
|
1131
|
+
* throw e;
|
|
1132
|
+
* });
|
|
1133
|
+
*
|
|
1134
|
+
* ```
|
|
526
1135
|
*
|
|
527
1136
|
* @param params - Parameters for request
|
|
528
1137
|
* @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
|
|
529
1138
|
* @param callback - Optional callback that handles the response.
|
|
530
1139
|
* @returns A promise if used with async/await, or void if used with a callback.
|
|
531
1140
|
*/
|
|
532
|
-
create(params: Params$Resource$Projects$Locations$Catalogs$Databases$Tables$Create, options: StreamMethodOptions):
|
|
533
|
-
create(params?: Params$Resource$Projects$Locations$Catalogs$Databases$Tables$Create, options?: MethodOptions):
|
|
1141
|
+
create(params: Params$Resource$Projects$Locations$Catalogs$Databases$Tables$Create, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
|
|
1142
|
+
create(params?: Params$Resource$Projects$Locations$Catalogs$Databases$Tables$Create, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$Table>>;
|
|
534
1143
|
create(params: Params$Resource$Projects$Locations$Catalogs$Databases$Tables$Create, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
|
|
535
1144
|
create(params: Params$Resource$Projects$Locations$Catalogs$Databases$Tables$Create, options: MethodOptions | BodyResponseCallback<Schema$Table>, callback: BodyResponseCallback<Schema$Table>): void;
|
|
536
1145
|
create(params: Params$Resource$Projects$Locations$Catalogs$Databases$Tables$Create, callback: BodyResponseCallback<Schema$Table>): void;
|
|
537
1146
|
create(callback: BodyResponseCallback<Schema$Table>): void;
|
|
538
1147
|
/**
|
|
539
1148
|
* Deletes an existing table specified by the table ID.
|
|
1149
|
+
* @example
|
|
1150
|
+
* ```js
|
|
1151
|
+
* // Before running the sample:
|
|
1152
|
+
* // - Enable the API at:
|
|
1153
|
+
* // https://console.developers.google.com/apis/api/biglake.googleapis.com
|
|
1154
|
+
* // - Login into gcloud by running:
|
|
1155
|
+
* // ```sh
|
|
1156
|
+
* // $ gcloud auth application-default login
|
|
1157
|
+
* // ```
|
|
1158
|
+
* // - Install the npm module by running:
|
|
1159
|
+
* // ```sh
|
|
1160
|
+
* // $ npm install googleapis
|
|
1161
|
+
* // ```
|
|
1162
|
+
*
|
|
1163
|
+
* const {google} = require('googleapis');
|
|
1164
|
+
* const biglake = google.biglake('v1');
|
|
1165
|
+
*
|
|
1166
|
+
* async function main() {
|
|
1167
|
+
* const auth = new google.auth.GoogleAuth({
|
|
1168
|
+
* // Scopes can be specified either as an array or as a single, space-delimited string.
|
|
1169
|
+
* scopes: [
|
|
1170
|
+
* 'https://www.googleapis.com/auth/bigquery',
|
|
1171
|
+
* 'https://www.googleapis.com/auth/cloud-platform',
|
|
1172
|
+
* ],
|
|
1173
|
+
* });
|
|
1174
|
+
*
|
|
1175
|
+
* // Acquire an auth client, and bind it to all future calls
|
|
1176
|
+
* const authClient = await auth.getClient();
|
|
1177
|
+
* google.options({auth: authClient});
|
|
1178
|
+
*
|
|
1179
|
+
* // Do the magic
|
|
1180
|
+
* const res = await biglake.projects.locations.catalogs.databases.tables.delete(
|
|
1181
|
+
* {
|
|
1182
|
+
* // Required. The name of the table to delete. Format: projects/{project_id_or_number\}/locations/{location_id\}/catalogs/{catalog_id\}/databases/{database_id\}/tables/{table_id\}
|
|
1183
|
+
* name: 'projects/my-project/locations/my-location/catalogs/my-catalog/databases/my-database/tables/my-table',
|
|
1184
|
+
* },
|
|
1185
|
+
* );
|
|
1186
|
+
* console.log(res.data);
|
|
1187
|
+
*
|
|
1188
|
+
* // Example response
|
|
1189
|
+
* // {
|
|
1190
|
+
* // "createTime": "my_createTime",
|
|
1191
|
+
* // "deleteTime": "my_deleteTime",
|
|
1192
|
+
* // "etag": "my_etag",
|
|
1193
|
+
* // "expireTime": "my_expireTime",
|
|
1194
|
+
* // "hiveOptions": {},
|
|
1195
|
+
* // "name": "my_name",
|
|
1196
|
+
* // "type": "my_type",
|
|
1197
|
+
* // "updateTime": "my_updateTime"
|
|
1198
|
+
* // }
|
|
1199
|
+
* }
|
|
1200
|
+
*
|
|
1201
|
+
* main().catch(e => {
|
|
1202
|
+
* console.error(e);
|
|
1203
|
+
* throw e;
|
|
1204
|
+
* });
|
|
1205
|
+
*
|
|
1206
|
+
* ```
|
|
540
1207
|
*
|
|
541
1208
|
* @param params - Parameters for request
|
|
542
1209
|
* @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
|
|
543
1210
|
* @param callback - Optional callback that handles the response.
|
|
544
1211
|
* @returns A promise if used with async/await, or void if used with a callback.
|
|
545
1212
|
*/
|
|
546
|
-
delete(params: Params$Resource$Projects$Locations$Catalogs$Databases$Tables$Delete, options: StreamMethodOptions):
|
|
547
|
-
delete(params?: Params$Resource$Projects$Locations$Catalogs$Databases$Tables$Delete, options?: MethodOptions):
|
|
1213
|
+
delete(params: Params$Resource$Projects$Locations$Catalogs$Databases$Tables$Delete, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
|
|
1214
|
+
delete(params?: Params$Resource$Projects$Locations$Catalogs$Databases$Tables$Delete, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$Table>>;
|
|
548
1215
|
delete(params: Params$Resource$Projects$Locations$Catalogs$Databases$Tables$Delete, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
|
|
549
1216
|
delete(params: Params$Resource$Projects$Locations$Catalogs$Databases$Tables$Delete, options: MethodOptions | BodyResponseCallback<Schema$Table>, callback: BodyResponseCallback<Schema$Table>): void;
|
|
550
1217
|
delete(params: Params$Resource$Projects$Locations$Catalogs$Databases$Tables$Delete, callback: BodyResponseCallback<Schema$Table>): void;
|
|
551
1218
|
delete(callback: BodyResponseCallback<Schema$Table>): void;
|
|
552
1219
|
/**
|
|
553
1220
|
* Gets the table specified by the resource name.
|
|
1221
|
+
* @example
|
|
1222
|
+
* ```js
|
|
1223
|
+
* // Before running the sample:
|
|
1224
|
+
* // - Enable the API at:
|
|
1225
|
+
* // https://console.developers.google.com/apis/api/biglake.googleapis.com
|
|
1226
|
+
* // - Login into gcloud by running:
|
|
1227
|
+
* // ```sh
|
|
1228
|
+
* // $ gcloud auth application-default login
|
|
1229
|
+
* // ```
|
|
1230
|
+
* // - Install the npm module by running:
|
|
1231
|
+
* // ```sh
|
|
1232
|
+
* // $ npm install googleapis
|
|
1233
|
+
* // ```
|
|
1234
|
+
*
|
|
1235
|
+
* const {google} = require('googleapis');
|
|
1236
|
+
* const biglake = google.biglake('v1');
|
|
1237
|
+
*
|
|
1238
|
+
* async function main() {
|
|
1239
|
+
* const auth = new google.auth.GoogleAuth({
|
|
1240
|
+
* // Scopes can be specified either as an array or as a single, space-delimited string.
|
|
1241
|
+
* scopes: [
|
|
1242
|
+
* 'https://www.googleapis.com/auth/bigquery',
|
|
1243
|
+
* 'https://www.googleapis.com/auth/cloud-platform',
|
|
1244
|
+
* ],
|
|
1245
|
+
* });
|
|
1246
|
+
*
|
|
1247
|
+
* // Acquire an auth client, and bind it to all future calls
|
|
1248
|
+
* const authClient = await auth.getClient();
|
|
1249
|
+
* google.options({auth: authClient});
|
|
1250
|
+
*
|
|
1251
|
+
* // Do the magic
|
|
1252
|
+
* const res = await biglake.projects.locations.catalogs.databases.tables.get({
|
|
1253
|
+
* // Required. The name of the table to retrieve. Format: projects/{project_id_or_number\}/locations/{location_id\}/catalogs/{catalog_id\}/databases/{database_id\}/tables/{table_id\}
|
|
1254
|
+
* name: 'projects/my-project/locations/my-location/catalogs/my-catalog/databases/my-database/tables/my-table',
|
|
1255
|
+
* });
|
|
1256
|
+
* console.log(res.data);
|
|
1257
|
+
*
|
|
1258
|
+
* // Example response
|
|
1259
|
+
* // {
|
|
1260
|
+
* // "createTime": "my_createTime",
|
|
1261
|
+
* // "deleteTime": "my_deleteTime",
|
|
1262
|
+
* // "etag": "my_etag",
|
|
1263
|
+
* // "expireTime": "my_expireTime",
|
|
1264
|
+
* // "hiveOptions": {},
|
|
1265
|
+
* // "name": "my_name",
|
|
1266
|
+
* // "type": "my_type",
|
|
1267
|
+
* // "updateTime": "my_updateTime"
|
|
1268
|
+
* // }
|
|
1269
|
+
* }
|
|
1270
|
+
*
|
|
1271
|
+
* main().catch(e => {
|
|
1272
|
+
* console.error(e);
|
|
1273
|
+
* throw e;
|
|
1274
|
+
* });
|
|
1275
|
+
*
|
|
1276
|
+
* ```
|
|
554
1277
|
*
|
|
555
1278
|
* @param params - Parameters for request
|
|
556
1279
|
* @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
|
|
557
1280
|
* @param callback - Optional callback that handles the response.
|
|
558
1281
|
* @returns A promise if used with async/await, or void if used with a callback.
|
|
559
1282
|
*/
|
|
560
|
-
get(params: Params$Resource$Projects$Locations$Catalogs$Databases$Tables$Get, options: StreamMethodOptions):
|
|
561
|
-
get(params?: Params$Resource$Projects$Locations$Catalogs$Databases$Tables$Get, options?: MethodOptions):
|
|
1283
|
+
get(params: Params$Resource$Projects$Locations$Catalogs$Databases$Tables$Get, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
|
|
1284
|
+
get(params?: Params$Resource$Projects$Locations$Catalogs$Databases$Tables$Get, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$Table>>;
|
|
562
1285
|
get(params: Params$Resource$Projects$Locations$Catalogs$Databases$Tables$Get, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
|
|
563
1286
|
get(params: Params$Resource$Projects$Locations$Catalogs$Databases$Tables$Get, options: MethodOptions | BodyResponseCallback<Schema$Table>, callback: BodyResponseCallback<Schema$Table>): void;
|
|
564
1287
|
get(params: Params$Resource$Projects$Locations$Catalogs$Databases$Tables$Get, callback: BodyResponseCallback<Schema$Table>): void;
|
|
565
1288
|
get(callback: BodyResponseCallback<Schema$Table>): void;
|
|
566
1289
|
/**
|
|
567
1290
|
* List all tables in a specified database.
|
|
1291
|
+
* @example
|
|
1292
|
+
* ```js
|
|
1293
|
+
* // Before running the sample:
|
|
1294
|
+
* // - Enable the API at:
|
|
1295
|
+
* // https://console.developers.google.com/apis/api/biglake.googleapis.com
|
|
1296
|
+
* // - Login into gcloud by running:
|
|
1297
|
+
* // ```sh
|
|
1298
|
+
* // $ gcloud auth application-default login
|
|
1299
|
+
* // ```
|
|
1300
|
+
* // - Install the npm module by running:
|
|
1301
|
+
* // ```sh
|
|
1302
|
+
* // $ npm install googleapis
|
|
1303
|
+
* // ```
|
|
1304
|
+
*
|
|
1305
|
+
* const {google} = require('googleapis');
|
|
1306
|
+
* const biglake = google.biglake('v1');
|
|
1307
|
+
*
|
|
1308
|
+
* async function main() {
|
|
1309
|
+
* const auth = new google.auth.GoogleAuth({
|
|
1310
|
+
* // Scopes can be specified either as an array or as a single, space-delimited string.
|
|
1311
|
+
* scopes: [
|
|
1312
|
+
* 'https://www.googleapis.com/auth/bigquery',
|
|
1313
|
+
* 'https://www.googleapis.com/auth/cloud-platform',
|
|
1314
|
+
* ],
|
|
1315
|
+
* });
|
|
1316
|
+
*
|
|
1317
|
+
* // Acquire an auth client, and bind it to all future calls
|
|
1318
|
+
* const authClient = await auth.getClient();
|
|
1319
|
+
* google.options({auth: authClient});
|
|
1320
|
+
*
|
|
1321
|
+
* // Do the magic
|
|
1322
|
+
* const res = await biglake.projects.locations.catalogs.databases.tables.list({
|
|
1323
|
+
* // The maximum number of tables to return. The service may return fewer than this value. If unspecified, at most 50 tables will be returned. The maximum value is 1000; values above 1000 will be coerced to 1000.
|
|
1324
|
+
* pageSize: 'placeholder-value',
|
|
1325
|
+
* // A page token, received from a previous `ListTables` call. Provide this to retrieve the subsequent page. When paginating, all other parameters provided to `ListTables` must match the call that provided the page token.
|
|
1326
|
+
* pageToken: 'placeholder-value',
|
|
1327
|
+
* // Required. The parent, which owns this collection of tables. Format: projects/{project_id_or_number\}/locations/{location_id\}/catalogs/{catalog_id\}/databases/{database_id\}
|
|
1328
|
+
* parent:
|
|
1329
|
+
* 'projects/my-project/locations/my-location/catalogs/my-catalog/databases/my-database',
|
|
1330
|
+
* // The view for the returned tables.
|
|
1331
|
+
* view: 'placeholder-value',
|
|
1332
|
+
* });
|
|
1333
|
+
* console.log(res.data);
|
|
1334
|
+
*
|
|
1335
|
+
* // Example response
|
|
1336
|
+
* // {
|
|
1337
|
+
* // "nextPageToken": "my_nextPageToken",
|
|
1338
|
+
* // "tables": []
|
|
1339
|
+
* // }
|
|
1340
|
+
* }
|
|
1341
|
+
*
|
|
1342
|
+
* main().catch(e => {
|
|
1343
|
+
* console.error(e);
|
|
1344
|
+
* throw e;
|
|
1345
|
+
* });
|
|
1346
|
+
*
|
|
1347
|
+
* ```
|
|
568
1348
|
*
|
|
569
1349
|
* @param params - Parameters for request
|
|
570
1350
|
* @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
|
|
571
1351
|
* @param callback - Optional callback that handles the response.
|
|
572
1352
|
* @returns A promise if used with async/await, or void if used with a callback.
|
|
573
1353
|
*/
|
|
574
|
-
list(params: Params$Resource$Projects$Locations$Catalogs$Databases$Tables$List, options: StreamMethodOptions):
|
|
575
|
-
list(params?: Params$Resource$Projects$Locations$Catalogs$Databases$Tables$List, options?: MethodOptions):
|
|
1354
|
+
list(params: Params$Resource$Projects$Locations$Catalogs$Databases$Tables$List, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
|
|
1355
|
+
list(params?: Params$Resource$Projects$Locations$Catalogs$Databases$Tables$List, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$ListTablesResponse>>;
|
|
576
1356
|
list(params: Params$Resource$Projects$Locations$Catalogs$Databases$Tables$List, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
|
|
577
1357
|
list(params: Params$Resource$Projects$Locations$Catalogs$Databases$Tables$List, options: MethodOptions | BodyResponseCallback<Schema$ListTablesResponse>, callback: BodyResponseCallback<Schema$ListTablesResponse>): void;
|
|
578
1358
|
list(params: Params$Resource$Projects$Locations$Catalogs$Databases$Tables$List, callback: BodyResponseCallback<Schema$ListTablesResponse>): void;
|
|
579
1359
|
list(callback: BodyResponseCallback<Schema$ListTablesResponse>): void;
|
|
580
1360
|
/**
|
|
581
1361
|
* Updates an existing table specified by the table ID.
|
|
1362
|
+
* @example
|
|
1363
|
+
* ```js
|
|
1364
|
+
* // Before running the sample:
|
|
1365
|
+
* // - Enable the API at:
|
|
1366
|
+
* // https://console.developers.google.com/apis/api/biglake.googleapis.com
|
|
1367
|
+
* // - Login into gcloud by running:
|
|
1368
|
+
* // ```sh
|
|
1369
|
+
* // $ gcloud auth application-default login
|
|
1370
|
+
* // ```
|
|
1371
|
+
* // - Install the npm module by running:
|
|
1372
|
+
* // ```sh
|
|
1373
|
+
* // $ npm install googleapis
|
|
1374
|
+
* // ```
|
|
1375
|
+
*
|
|
1376
|
+
* const {google} = require('googleapis');
|
|
1377
|
+
* const biglake = google.biglake('v1');
|
|
1378
|
+
*
|
|
1379
|
+
* async function main() {
|
|
1380
|
+
* const auth = new google.auth.GoogleAuth({
|
|
1381
|
+
* // Scopes can be specified either as an array or as a single, space-delimited string.
|
|
1382
|
+
* scopes: [
|
|
1383
|
+
* 'https://www.googleapis.com/auth/bigquery',
|
|
1384
|
+
* 'https://www.googleapis.com/auth/cloud-platform',
|
|
1385
|
+
* ],
|
|
1386
|
+
* });
|
|
1387
|
+
*
|
|
1388
|
+
* // Acquire an auth client, and bind it to all future calls
|
|
1389
|
+
* const authClient = await auth.getClient();
|
|
1390
|
+
* google.options({auth: authClient});
|
|
1391
|
+
*
|
|
1392
|
+
* // Do the magic
|
|
1393
|
+
* const res = await biglake.projects.locations.catalogs.databases.tables.patch({
|
|
1394
|
+
* // Output only. The resource name. Format: projects/{project_id_or_number\}/locations/{location_id\}/catalogs/{catalog_id\}/databases/{database_id\}/tables/{table_id\}
|
|
1395
|
+
* name: 'projects/my-project/locations/my-location/catalogs/my-catalog/databases/my-database/tables/my-table',
|
|
1396
|
+
* // The list of fields to update. For the `FieldMask` definition, see https://developers.google.com/protocol-buffers/docs/reference/google.protobuf#fieldmask If not set, defaults to all of the fields that are allowed to update.
|
|
1397
|
+
* updateMask: 'placeholder-value',
|
|
1398
|
+
*
|
|
1399
|
+
* // Request body metadata
|
|
1400
|
+
* requestBody: {
|
|
1401
|
+
* // request body parameters
|
|
1402
|
+
* // {
|
|
1403
|
+
* // "createTime": "my_createTime",
|
|
1404
|
+
* // "deleteTime": "my_deleteTime",
|
|
1405
|
+
* // "etag": "my_etag",
|
|
1406
|
+
* // "expireTime": "my_expireTime",
|
|
1407
|
+
* // "hiveOptions": {},
|
|
1408
|
+
* // "name": "my_name",
|
|
1409
|
+
* // "type": "my_type",
|
|
1410
|
+
* // "updateTime": "my_updateTime"
|
|
1411
|
+
* // }
|
|
1412
|
+
* },
|
|
1413
|
+
* });
|
|
1414
|
+
* console.log(res.data);
|
|
1415
|
+
*
|
|
1416
|
+
* // Example response
|
|
1417
|
+
* // {
|
|
1418
|
+
* // "createTime": "my_createTime",
|
|
1419
|
+
* // "deleteTime": "my_deleteTime",
|
|
1420
|
+
* // "etag": "my_etag",
|
|
1421
|
+
* // "expireTime": "my_expireTime",
|
|
1422
|
+
* // "hiveOptions": {},
|
|
1423
|
+
* // "name": "my_name",
|
|
1424
|
+
* // "type": "my_type",
|
|
1425
|
+
* // "updateTime": "my_updateTime"
|
|
1426
|
+
* // }
|
|
1427
|
+
* }
|
|
1428
|
+
*
|
|
1429
|
+
* main().catch(e => {
|
|
1430
|
+
* console.error(e);
|
|
1431
|
+
* throw e;
|
|
1432
|
+
* });
|
|
1433
|
+
*
|
|
1434
|
+
* ```
|
|
582
1435
|
*
|
|
583
1436
|
* @param params - Parameters for request
|
|
584
1437
|
* @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
|
|
585
1438
|
* @param callback - Optional callback that handles the response.
|
|
586
1439
|
* @returns A promise if used with async/await, or void if used with a callback.
|
|
587
1440
|
*/
|
|
588
|
-
patch(params: Params$Resource$Projects$Locations$Catalogs$Databases$Tables$Patch, options: StreamMethodOptions):
|
|
589
|
-
patch(params?: Params$Resource$Projects$Locations$Catalogs$Databases$Tables$Patch, options?: MethodOptions):
|
|
1441
|
+
patch(params: Params$Resource$Projects$Locations$Catalogs$Databases$Tables$Patch, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
|
|
1442
|
+
patch(params?: Params$Resource$Projects$Locations$Catalogs$Databases$Tables$Patch, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$Table>>;
|
|
590
1443
|
patch(params: Params$Resource$Projects$Locations$Catalogs$Databases$Tables$Patch, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
|
|
591
1444
|
patch(params: Params$Resource$Projects$Locations$Catalogs$Databases$Tables$Patch, options: MethodOptions | BodyResponseCallback<Schema$Table>, callback: BodyResponseCallback<Schema$Table>): void;
|
|
592
1445
|
patch(params: Params$Resource$Projects$Locations$Catalogs$Databases$Tables$Patch, callback: BodyResponseCallback<Schema$Table>): void;
|
|
593
1446
|
patch(callback: BodyResponseCallback<Schema$Table>): void;
|
|
594
1447
|
/**
|
|
595
1448
|
* Renames an existing table specified by the table ID.
|
|
1449
|
+
* @example
|
|
1450
|
+
* ```js
|
|
1451
|
+
* // Before running the sample:
|
|
1452
|
+
* // - Enable the API at:
|
|
1453
|
+
* // https://console.developers.google.com/apis/api/biglake.googleapis.com
|
|
1454
|
+
* // - Login into gcloud by running:
|
|
1455
|
+
* // ```sh
|
|
1456
|
+
* // $ gcloud auth application-default login
|
|
1457
|
+
* // ```
|
|
1458
|
+
* // - Install the npm module by running:
|
|
1459
|
+
* // ```sh
|
|
1460
|
+
* // $ npm install googleapis
|
|
1461
|
+
* // ```
|
|
1462
|
+
*
|
|
1463
|
+
* const {google} = require('googleapis');
|
|
1464
|
+
* const biglake = google.biglake('v1');
|
|
1465
|
+
*
|
|
1466
|
+
* async function main() {
|
|
1467
|
+
* const auth = new google.auth.GoogleAuth({
|
|
1468
|
+
* // Scopes can be specified either as an array or as a single, space-delimited string.
|
|
1469
|
+
* scopes: [
|
|
1470
|
+
* 'https://www.googleapis.com/auth/bigquery',
|
|
1471
|
+
* 'https://www.googleapis.com/auth/cloud-platform',
|
|
1472
|
+
* ],
|
|
1473
|
+
* });
|
|
1474
|
+
*
|
|
1475
|
+
* // Acquire an auth client, and bind it to all future calls
|
|
1476
|
+
* const authClient = await auth.getClient();
|
|
1477
|
+
* google.options({auth: authClient});
|
|
1478
|
+
*
|
|
1479
|
+
* // Do the magic
|
|
1480
|
+
* const res = await biglake.projects.locations.catalogs.databases.tables.rename(
|
|
1481
|
+
* {
|
|
1482
|
+
* // Required. The table's `name` field is used to identify the table to rename. Format: projects/{project_id_or_number\}/locations/{location_id\}/catalogs/{catalog_id\}/databases/{database_id\}/tables/{table_id\}
|
|
1483
|
+
* name: 'projects/my-project/locations/my-location/catalogs/my-catalog/databases/my-database/tables/my-table',
|
|
1484
|
+
*
|
|
1485
|
+
* // Request body metadata
|
|
1486
|
+
* requestBody: {
|
|
1487
|
+
* // request body parameters
|
|
1488
|
+
* // {
|
|
1489
|
+
* // "newName": "my_newName"
|
|
1490
|
+
* // }
|
|
1491
|
+
* },
|
|
1492
|
+
* },
|
|
1493
|
+
* );
|
|
1494
|
+
* console.log(res.data);
|
|
1495
|
+
*
|
|
1496
|
+
* // Example response
|
|
1497
|
+
* // {
|
|
1498
|
+
* // "createTime": "my_createTime",
|
|
1499
|
+
* // "deleteTime": "my_deleteTime",
|
|
1500
|
+
* // "etag": "my_etag",
|
|
1501
|
+
* // "expireTime": "my_expireTime",
|
|
1502
|
+
* // "hiveOptions": {},
|
|
1503
|
+
* // "name": "my_name",
|
|
1504
|
+
* // "type": "my_type",
|
|
1505
|
+
* // "updateTime": "my_updateTime"
|
|
1506
|
+
* // }
|
|
1507
|
+
* }
|
|
1508
|
+
*
|
|
1509
|
+
* main().catch(e => {
|
|
1510
|
+
* console.error(e);
|
|
1511
|
+
* throw e;
|
|
1512
|
+
* });
|
|
1513
|
+
*
|
|
1514
|
+
* ```
|
|
596
1515
|
*
|
|
597
1516
|
* @param params - Parameters for request
|
|
598
1517
|
* @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
|
|
599
1518
|
* @param callback - Optional callback that handles the response.
|
|
600
1519
|
* @returns A promise if used with async/await, or void if used with a callback.
|
|
601
1520
|
*/
|
|
602
|
-
rename(params: Params$Resource$Projects$Locations$Catalogs$Databases$Tables$Rename, options: StreamMethodOptions):
|
|
603
|
-
rename(params?: Params$Resource$Projects$Locations$Catalogs$Databases$Tables$Rename, options?: MethodOptions):
|
|
1521
|
+
rename(params: Params$Resource$Projects$Locations$Catalogs$Databases$Tables$Rename, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
|
|
1522
|
+
rename(params?: Params$Resource$Projects$Locations$Catalogs$Databases$Tables$Rename, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$Table>>;
|
|
604
1523
|
rename(params: Params$Resource$Projects$Locations$Catalogs$Databases$Tables$Rename, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
|
|
605
1524
|
rename(params: Params$Resource$Projects$Locations$Catalogs$Databases$Tables$Rename, options: MethodOptions | BodyResponseCallback<Schema$Table>, callback: BodyResponseCallback<Schema$Table>): void;
|
|
606
1525
|
rename(params: Params$Resource$Projects$Locations$Catalogs$Databases$Tables$Rename, callback: BodyResponseCallback<Schema$Table>): void;
|