Home | History | Annotate | Download | only in bigquery_v2
      1 """Generated client library for bigquery version v2."""
      2 # NOTE: This file is autogenerated and should not be edited by hand.
      3 from apitools.base.py import base_api
      4 from samples.bigquery_sample.bigquery_v2 import bigquery_v2_messages as messages
      5 
      6 
      7 class BigqueryV2(base_api.BaseApiClient):
      8   """Generated client library for service bigquery version v2."""
      9 
     10   MESSAGES_MODULE = messages
     11   BASE_URL = u'https://www.googleapis.com/bigquery/v2/'
     12 
     13   _PACKAGE = u'bigquery'
     14   _SCOPES = [u'https://www.googleapis.com/auth/bigquery', u'https://www.googleapis.com/auth/bigquery.insertdata', u'https://www.googleapis.com/auth/cloud-platform', u'https://www.googleapis.com/auth/cloud-platform.read-only', u'https://www.googleapis.com/auth/devstorage.full_control', u'https://www.googleapis.com/auth/devstorage.read_only', u'https://www.googleapis.com/auth/devstorage.read_write']
     15   _VERSION = u'v2'
     16   _CLIENT_ID = '1042881264118.apps.googleusercontent.com'
     17   _CLIENT_SECRET = 'x_Tw5K8nnjoRAqULM9PFAC2b'
     18   _USER_AGENT = 'x_Tw5K8nnjoRAqULM9PFAC2b'
     19   _CLIENT_CLASS_NAME = u'BigqueryV2'
     20   _URL_VERSION = u'v2'
     21   _API_KEY = None
     22 
     23   def __init__(self, url='', credentials=None,
     24                get_credentials=True, http=None, model=None,
     25                log_request=False, log_response=False,
     26                credentials_args=None, default_global_params=None,
     27                additional_http_headers=None):
     28     """Create a new bigquery handle."""
     29     url = url or self.BASE_URL
     30     super(BigqueryV2, self).__init__(
     31         url, credentials=credentials,
     32         get_credentials=get_credentials, http=http, model=model,
     33         log_request=log_request, log_response=log_response,
     34         credentials_args=credentials_args,
     35         default_global_params=default_global_params,
     36         additional_http_headers=additional_http_headers)
     37     self.datasets = self.DatasetsService(self)
     38     self.jobs = self.JobsService(self)
     39     self.projects = self.ProjectsService(self)
     40     self.tabledata = self.TabledataService(self)
     41     self.tables = self.TablesService(self)
     42 
     43   class DatasetsService(base_api.BaseApiService):
     44     """Service class for the datasets resource."""
     45 
     46     _NAME = u'datasets'
     47 
     48     def __init__(self, client):
     49       super(BigqueryV2.DatasetsService, self).__init__(client)
     50       self._upload_configs = {
     51           }
     52 
     53     def Delete(self, request, global_params=None):
     54       """Deletes the dataset specified by the datasetId value. Before you can delete a dataset, you must delete all its tables, either manually or by specifying deleteContents. Immediately after deletion, you can create another dataset with the same name.
     55 
     56       Args:
     57         request: (BigqueryDatasetsDeleteRequest) input message
     58         global_params: (StandardQueryParameters, default: None) global arguments
     59       Returns:
     60         (BigqueryDatasetsDeleteResponse) The response message.
     61       """
     62       config = self.GetMethodConfig('Delete')
     63       return self._RunMethod(
     64           config, request, global_params=global_params)
     65 
     66     Delete.method_config = lambda: base_api.ApiMethodInfo(
     67         http_method=u'DELETE',
     68         method_id=u'bigquery.datasets.delete',
     69         ordered_params=[u'projectId', u'datasetId'],
     70         path_params=[u'datasetId', u'projectId'],
     71         query_params=[u'deleteContents'],
     72         relative_path=u'projects/{projectId}/datasets/{datasetId}',
     73         request_field='',
     74         request_type_name=u'BigqueryDatasetsDeleteRequest',
     75         response_type_name=u'BigqueryDatasetsDeleteResponse',
     76         supports_download=False,
     77     )
     78 
     79     def Get(self, request, global_params=None):
     80       """Returns the dataset specified by datasetID.
     81 
     82       Args:
     83         request: (BigqueryDatasetsGetRequest) input message
     84         global_params: (StandardQueryParameters, default: None) global arguments
     85       Returns:
     86         (Dataset) The response message.
     87       """
     88       config = self.GetMethodConfig('Get')
     89       return self._RunMethod(
     90           config, request, global_params=global_params)
     91 
     92     Get.method_config = lambda: base_api.ApiMethodInfo(
     93         http_method=u'GET',
     94         method_id=u'bigquery.datasets.get',
     95         ordered_params=[u'projectId', u'datasetId'],
     96         path_params=[u'datasetId', u'projectId'],
     97         query_params=[],
     98         relative_path=u'projects/{projectId}/datasets/{datasetId}',
     99         request_field='',
    100         request_type_name=u'BigqueryDatasetsGetRequest',
    101         response_type_name=u'Dataset',
    102         supports_download=False,
    103     )
    104 
    105     def Insert(self, request, global_params=None):
    106       """Creates a new empty dataset.
    107 
    108       Args:
    109         request: (BigqueryDatasetsInsertRequest) input message
    110         global_params: (StandardQueryParameters, default: None) global arguments
    111       Returns:
    112         (Dataset) The response message.
    113       """
    114       config = self.GetMethodConfig('Insert')
    115       return self._RunMethod(
    116           config, request, global_params=global_params)
    117 
    118     Insert.method_config = lambda: base_api.ApiMethodInfo(
    119         http_method=u'POST',
    120         method_id=u'bigquery.datasets.insert',
    121         ordered_params=[u'projectId'],
    122         path_params=[u'projectId'],
    123         query_params=[],
    124         relative_path=u'projects/{projectId}/datasets',
    125         request_field=u'dataset',
    126         request_type_name=u'BigqueryDatasetsInsertRequest',
    127         response_type_name=u'Dataset',
    128         supports_download=False,
    129     )
    130 
    131     def List(self, request, global_params=None):
    132       """Lists all datasets in the specified project to which you have been granted the READER dataset role.
    133 
    134       Args:
    135         request: (BigqueryDatasetsListRequest) input message
    136         global_params: (StandardQueryParameters, default: None) global arguments
    137       Returns:
    138         (DatasetList) The response message.
    139       """
    140       config = self.GetMethodConfig('List')
    141       return self._RunMethod(
    142           config, request, global_params=global_params)
    143 
    144     List.method_config = lambda: base_api.ApiMethodInfo(
    145         http_method=u'GET',
    146         method_id=u'bigquery.datasets.list',
    147         ordered_params=[u'projectId'],
    148         path_params=[u'projectId'],
    149         query_params=[u'all', u'filter', u'maxResults', u'pageToken'],
    150         relative_path=u'projects/{projectId}/datasets',
    151         request_field='',
    152         request_type_name=u'BigqueryDatasetsListRequest',
    153         response_type_name=u'DatasetList',
    154         supports_download=False,
    155     )
    156 
    157     def Patch(self, request, global_params=None):
    158       """Updates information in an existing dataset. The update method replaces the entire dataset resource, whereas the patch method only replaces fields that are provided in the submitted dataset resource. This method supports patch semantics.
    159 
    160       Args:
    161         request: (BigqueryDatasetsPatchRequest) input message
    162         global_params: (StandardQueryParameters, default: None) global arguments
    163       Returns:
    164         (Dataset) The response message.
    165       """
    166       config = self.GetMethodConfig('Patch')
    167       return self._RunMethod(
    168           config, request, global_params=global_params)
    169 
    170     Patch.method_config = lambda: base_api.ApiMethodInfo(
    171         http_method=u'PATCH',
    172         method_id=u'bigquery.datasets.patch',
    173         ordered_params=[u'projectId', u'datasetId'],
    174         path_params=[u'datasetId', u'projectId'],
    175         query_params=[],
    176         relative_path=u'projects/{projectId}/datasets/{datasetId}',
    177         request_field=u'dataset',
    178         request_type_name=u'BigqueryDatasetsPatchRequest',
    179         response_type_name=u'Dataset',
    180         supports_download=False,
    181     )
    182 
    183     def Update(self, request, global_params=None):
    184       """Updates information in an existing dataset. The update method replaces the entire dataset resource, whereas the patch method only replaces fields that are provided in the submitted dataset resource.
    185 
    186       Args:
    187         request: (BigqueryDatasetsUpdateRequest) input message
    188         global_params: (StandardQueryParameters, default: None) global arguments
    189       Returns:
    190         (Dataset) The response message.
    191       """
    192       config = self.GetMethodConfig('Update')
    193       return self._RunMethod(
    194           config, request, global_params=global_params)
    195 
    196     Update.method_config = lambda: base_api.ApiMethodInfo(
    197         http_method=u'PUT',
    198         method_id=u'bigquery.datasets.update',
    199         ordered_params=[u'projectId', u'datasetId'],
    200         path_params=[u'datasetId', u'projectId'],
    201         query_params=[],
    202         relative_path=u'projects/{projectId}/datasets/{datasetId}',
    203         request_field=u'dataset',
    204         request_type_name=u'BigqueryDatasetsUpdateRequest',
    205         response_type_name=u'Dataset',
    206         supports_download=False,
    207     )
    208 
    209   class JobsService(base_api.BaseApiService):
    210     """Service class for the jobs resource."""
    211 
    212     _NAME = u'jobs'
    213 
    214     def __init__(self, client):
    215       super(BigqueryV2.JobsService, self).__init__(client)
    216       self._upload_configs = {
    217           'Insert': base_api.ApiUploadInfo(
    218               accept=['*/*'],
    219               max_size=None,
    220               resumable_multipart=True,
    221               resumable_path=u'/resumable/upload/bigquery/v2/projects/{projectId}/jobs',
    222               simple_multipart=True,
    223               simple_path=u'/upload/bigquery/v2/projects/{projectId}/jobs',
    224           ),
    225           }
    226 
    227     def Cancel(self, request, global_params=None):
    228       """Requests that a job be cancelled. This call will return immediately, and the client will need to poll for the job status to see if the cancel completed successfully. Cancelled jobs may still incur costs.
    229 
    230       Args:
    231         request: (BigqueryJobsCancelRequest) input message
    232         global_params: (StandardQueryParameters, default: None) global arguments
    233       Returns:
    234         (JobCancelResponse) The response message.
    235       """
    236       config = self.GetMethodConfig('Cancel')
    237       return self._RunMethod(
    238           config, request, global_params=global_params)
    239 
    240     Cancel.method_config = lambda: base_api.ApiMethodInfo(
    241         http_method=u'POST',
    242         method_id=u'bigquery.jobs.cancel',
    243         ordered_params=[u'projectId', u'jobId'],
    244         path_params=[u'jobId', u'projectId'],
    245         query_params=[],
    246         relative_path=u'project/{projectId}/jobs/{jobId}/cancel',
    247         request_field='',
    248         request_type_name=u'BigqueryJobsCancelRequest',
    249         response_type_name=u'JobCancelResponse',
    250         supports_download=False,
    251     )
    252 
    253     def Get(self, request, global_params=None):
    254       """Returns information about a specific job. Job information is available for a six month period after creation. Requires that you're the person who ran the job, or have the Is Owner project role.
    255 
    256       Args:
    257         request: (BigqueryJobsGetRequest) input message
    258         global_params: (StandardQueryParameters, default: None) global arguments
    259       Returns:
    260         (Job) The response message.
    261       """
    262       config = self.GetMethodConfig('Get')
    263       return self._RunMethod(
    264           config, request, global_params=global_params)
    265 
    266     Get.method_config = lambda: base_api.ApiMethodInfo(
    267         http_method=u'GET',
    268         method_id=u'bigquery.jobs.get',
    269         ordered_params=[u'projectId', u'jobId'],
    270         path_params=[u'jobId', u'projectId'],
    271         query_params=[],
    272         relative_path=u'projects/{projectId}/jobs/{jobId}',
    273         request_field='',
    274         request_type_name=u'BigqueryJobsGetRequest',
    275         response_type_name=u'Job',
    276         supports_download=False,
    277     )
    278 
    279     def GetQueryResults(self, request, global_params=None):
    280       """Retrieves the results of a query job.
    281 
    282       Args:
    283         request: (BigqueryJobsGetQueryResultsRequest) input message
    284         global_params: (StandardQueryParameters, default: None) global arguments
    285       Returns:
    286         (GetQueryResultsResponse) The response message.
    287       """
    288       config = self.GetMethodConfig('GetQueryResults')
    289       return self._RunMethod(
    290           config, request, global_params=global_params)
    291 
    292     GetQueryResults.method_config = lambda: base_api.ApiMethodInfo(
    293         http_method=u'GET',
    294         method_id=u'bigquery.jobs.getQueryResults',
    295         ordered_params=[u'projectId', u'jobId'],
    296         path_params=[u'jobId', u'projectId'],
    297         query_params=[u'maxResults', u'pageToken', u'startIndex', u'timeoutMs'],
    298         relative_path=u'projects/{projectId}/queries/{jobId}',
    299         request_field='',
    300         request_type_name=u'BigqueryJobsGetQueryResultsRequest',
    301         response_type_name=u'GetQueryResultsResponse',
    302         supports_download=False,
    303     )
    304 
    305     def Insert(self, request, global_params=None, upload=None):
    306       """Starts a new asynchronous job. Requires the Can View project role.
    307 
    308       Args:
    309         request: (BigqueryJobsInsertRequest) input message
    310         global_params: (StandardQueryParameters, default: None) global arguments
    311         upload: (Upload, default: None) If present, upload
    312             this stream with the request.
    313       Returns:
    314         (Job) The response message.
    315       """
    316       config = self.GetMethodConfig('Insert')
    317       upload_config = self.GetUploadConfig('Insert')
    318       return self._RunMethod(
    319           config, request, global_params=global_params,
    320           upload=upload, upload_config=upload_config)
    321 
    322     Insert.method_config = lambda: base_api.ApiMethodInfo(
    323         http_method=u'POST',
    324         method_id=u'bigquery.jobs.insert',
    325         ordered_params=[u'projectId'],
    326         path_params=[u'projectId'],
    327         query_params=[],
    328         relative_path=u'projects/{projectId}/jobs',
    329         request_field=u'job',
    330         request_type_name=u'BigqueryJobsInsertRequest',
    331         response_type_name=u'Job',
    332         supports_download=False,
    333     )
    334 
    335     def List(self, request, global_params=None):
    336       """Lists all jobs that you started in the specified project. Job information is available for a six month period after creation. The job list is sorted in reverse chronological order, by job creation time. Requires the Can View project role, or the Is Owner project role if you set the allUsers property.
    337 
    338       Args:
    339         request: (BigqueryJobsListRequest) input message
    340         global_params: (StandardQueryParameters, default: None) global arguments
    341       Returns:
    342         (JobList) The response message.
    343       """
    344       config = self.GetMethodConfig('List')
    345       return self._RunMethod(
    346           config, request, global_params=global_params)
    347 
    348     List.method_config = lambda: base_api.ApiMethodInfo(
    349         http_method=u'GET',
    350         method_id=u'bigquery.jobs.list',
    351         ordered_params=[u'projectId'],
    352         path_params=[u'projectId'],
    353         query_params=[u'allUsers', u'maxResults', u'pageToken', u'projection', u'stateFilter'],
    354         relative_path=u'projects/{projectId}/jobs',
    355         request_field='',
    356         request_type_name=u'BigqueryJobsListRequest',
    357         response_type_name=u'JobList',
    358         supports_download=False,
    359     )
    360 
    361     def Query(self, request, global_params=None):
    362       """Runs a BigQuery SQL query synchronously and returns query results if the query completes within a specified timeout.
    363 
    364       Args:
    365         request: (BigqueryJobsQueryRequest) input message
    366         global_params: (StandardQueryParameters, default: None) global arguments
    367       Returns:
    368         (QueryResponse) The response message.
    369       """
    370       config = self.GetMethodConfig('Query')
    371       return self._RunMethod(
    372           config, request, global_params=global_params)
    373 
    374     Query.method_config = lambda: base_api.ApiMethodInfo(
    375         http_method=u'POST',
    376         method_id=u'bigquery.jobs.query',
    377         ordered_params=[u'projectId'],
    378         path_params=[u'projectId'],
    379         query_params=[],
    380         relative_path=u'projects/{projectId}/queries',
    381         request_field=u'queryRequest',
    382         request_type_name=u'BigqueryJobsQueryRequest',
    383         response_type_name=u'QueryResponse',
    384         supports_download=False,
    385     )
    386 
    387   class ProjectsService(base_api.BaseApiService):
    388     """Service class for the projects resource."""
    389 
    390     _NAME = u'projects'
    391 
    392     def __init__(self, client):
    393       super(BigqueryV2.ProjectsService, self).__init__(client)
    394       self._upload_configs = {
    395           }
    396 
    397     def List(self, request, global_params=None):
    398       """Lists all projects to which you have been granted any project role.
    399 
    400       Args:
    401         request: (BigqueryProjectsListRequest) input message
    402         global_params: (StandardQueryParameters, default: None) global arguments
    403       Returns:
    404         (ProjectList) The response message.
    405       """
    406       config = self.GetMethodConfig('List')
    407       return self._RunMethod(
    408           config, request, global_params=global_params)
    409 
    410     List.method_config = lambda: base_api.ApiMethodInfo(
    411         http_method=u'GET',
    412         method_id=u'bigquery.projects.list',
    413         ordered_params=[],
    414         path_params=[],
    415         query_params=[u'maxResults', u'pageToken'],
    416         relative_path=u'projects',
    417         request_field='',
    418         request_type_name=u'BigqueryProjectsListRequest',
    419         response_type_name=u'ProjectList',
    420         supports_download=False,
    421     )
    422 
    423   class TabledataService(base_api.BaseApiService):
    424     """Service class for the tabledata resource."""
    425 
    426     _NAME = u'tabledata'
    427 
    428     def __init__(self, client):
    429       super(BigqueryV2.TabledataService, self).__init__(client)
    430       self._upload_configs = {
    431           }
    432 
    433     def InsertAll(self, request, global_params=None):
    434       """Streams data into BigQuery one record at a time without needing to run a load job. Requires the WRITER dataset role.
    435 
    436       Args:
    437         request: (BigqueryTabledataInsertAllRequest) input message
    438         global_params: (StandardQueryParameters, default: None) global arguments
    439       Returns:
    440         (TableDataInsertAllResponse) The response message.
    441       """
    442       config = self.GetMethodConfig('InsertAll')
    443       return self._RunMethod(
    444           config, request, global_params=global_params)
    445 
    446     InsertAll.method_config = lambda: base_api.ApiMethodInfo(
    447         http_method=u'POST',
    448         method_id=u'bigquery.tabledata.insertAll',
    449         ordered_params=[u'projectId', u'datasetId', u'tableId'],
    450         path_params=[u'datasetId', u'projectId', u'tableId'],
    451         query_params=[],
    452         relative_path=u'projects/{projectId}/datasets/{datasetId}/tables/{tableId}/insertAll',
    453         request_field=u'tableDataInsertAllRequest',
    454         request_type_name=u'BigqueryTabledataInsertAllRequest',
    455         response_type_name=u'TableDataInsertAllResponse',
    456         supports_download=False,
    457     )
    458 
    459     def List(self, request, global_params=None):
    460       """Retrieves table data from a specified set of rows. Requires the READER dataset role.
    461 
    462       Args:
    463         request: (BigqueryTabledataListRequest) input message
    464         global_params: (StandardQueryParameters, default: None) global arguments
    465       Returns:
    466         (TableDataList) The response message.
    467       """
    468       config = self.GetMethodConfig('List')
    469       return self._RunMethod(
    470           config, request, global_params=global_params)
    471 
    472     List.method_config = lambda: base_api.ApiMethodInfo(
    473         http_method=u'GET',
    474         method_id=u'bigquery.tabledata.list',
    475         ordered_params=[u'projectId', u'datasetId', u'tableId'],
    476         path_params=[u'datasetId', u'projectId', u'tableId'],
    477         query_params=[u'maxResults', u'pageToken', u'startIndex'],
    478         relative_path=u'projects/{projectId}/datasets/{datasetId}/tables/{tableId}/data',
    479         request_field='',
    480         request_type_name=u'BigqueryTabledataListRequest',
    481         response_type_name=u'TableDataList',
    482         supports_download=False,
    483     )
    484 
    485   class TablesService(base_api.BaseApiService):
    486     """Service class for the tables resource."""
    487 
    488     _NAME = u'tables'
    489 
    490     def __init__(self, client):
    491       super(BigqueryV2.TablesService, self).__init__(client)
    492       self._upload_configs = {
    493           }
    494 
    495     def Delete(self, request, global_params=None):
    496       """Deletes the table specified by tableId from the dataset. If the table contains data, all the data will be deleted.
    497 
    498       Args:
    499         request: (BigqueryTablesDeleteRequest) input message
    500         global_params: (StandardQueryParameters, default: None) global arguments
    501       Returns:
    502         (BigqueryTablesDeleteResponse) The response message.
    503       """
    504       config = self.GetMethodConfig('Delete')
    505       return self._RunMethod(
    506           config, request, global_params=global_params)
    507 
    508     Delete.method_config = lambda: base_api.ApiMethodInfo(
    509         http_method=u'DELETE',
    510         method_id=u'bigquery.tables.delete',
    511         ordered_params=[u'projectId', u'datasetId', u'tableId'],
    512         path_params=[u'datasetId', u'projectId', u'tableId'],
    513         query_params=[],
    514         relative_path=u'projects/{projectId}/datasets/{datasetId}/tables/{tableId}',
    515         request_field='',
    516         request_type_name=u'BigqueryTablesDeleteRequest',
    517         response_type_name=u'BigqueryTablesDeleteResponse',
    518         supports_download=False,
    519     )
    520 
    521     def Get(self, request, global_params=None):
    522       """Gets the specified table resource by table ID. This method does not return the data in the table, it only returns the table resource, which describes the structure of this table.
    523 
    524       Args:
    525         request: (BigqueryTablesGetRequest) input message
    526         global_params: (StandardQueryParameters, default: None) global arguments
    527       Returns:
    528         (Table) The response message.
    529       """
    530       config = self.GetMethodConfig('Get')
    531       return self._RunMethod(
    532           config, request, global_params=global_params)
    533 
    534     Get.method_config = lambda: base_api.ApiMethodInfo(
    535         http_method=u'GET',
    536         method_id=u'bigquery.tables.get',
    537         ordered_params=[u'projectId', u'datasetId', u'tableId'],
    538         path_params=[u'datasetId', u'projectId', u'tableId'],
    539         query_params=[],
    540         relative_path=u'projects/{projectId}/datasets/{datasetId}/tables/{tableId}',
    541         request_field='',
    542         request_type_name=u'BigqueryTablesGetRequest',
    543         response_type_name=u'Table',
    544         supports_download=False,
    545     )
    546 
    547     def Insert(self, request, global_params=None):
    548       """Creates a new, empty table in the dataset.
    549 
    550       Args:
    551         request: (BigqueryTablesInsertRequest) input message
    552         global_params: (StandardQueryParameters, default: None) global arguments
    553       Returns:
    554         (Table) The response message.
    555       """
    556       config = self.GetMethodConfig('Insert')
    557       return self._RunMethod(
    558           config, request, global_params=global_params)
    559 
    560     Insert.method_config = lambda: base_api.ApiMethodInfo(
    561         http_method=u'POST',
    562         method_id=u'bigquery.tables.insert',
    563         ordered_params=[u'projectId', u'datasetId'],
    564         path_params=[u'datasetId', u'projectId'],
    565         query_params=[],
    566         relative_path=u'projects/{projectId}/datasets/{datasetId}/tables',
    567         request_field=u'table',
    568         request_type_name=u'BigqueryTablesInsertRequest',
    569         response_type_name=u'Table',
    570         supports_download=False,
    571     )
    572 
    573     def List(self, request, global_params=None):
    574       """Lists all tables in the specified dataset. Requires the READER dataset role.
    575 
    576       Args:
    577         request: (BigqueryTablesListRequest) input message
    578         global_params: (StandardQueryParameters, default: None) global arguments
    579       Returns:
    580         (TableList) The response message.
    581       """
    582       config = self.GetMethodConfig('List')
    583       return self._RunMethod(
    584           config, request, global_params=global_params)
    585 
    586     List.method_config = lambda: base_api.ApiMethodInfo(
    587         http_method=u'GET',
    588         method_id=u'bigquery.tables.list',
    589         ordered_params=[u'projectId', u'datasetId'],
    590         path_params=[u'datasetId', u'projectId'],
    591         query_params=[u'maxResults', u'pageToken'],
    592         relative_path=u'projects/{projectId}/datasets/{datasetId}/tables',
    593         request_field='',
    594         request_type_name=u'BigqueryTablesListRequest',
    595         response_type_name=u'TableList',
    596         supports_download=False,
    597     )
    598 
    599     def Patch(self, request, global_params=None):
    600       """Updates information in an existing table. The update method replaces the entire table resource, whereas the patch method only replaces fields that are provided in the submitted table resource. This method supports patch semantics.
    601 
    602       Args:
    603         request: (BigqueryTablesPatchRequest) input message
    604         global_params: (StandardQueryParameters, default: None) global arguments
    605       Returns:
    606         (Table) The response message.
    607       """
    608       config = self.GetMethodConfig('Patch')
    609       return self._RunMethod(
    610           config, request, global_params=global_params)
    611 
    612     Patch.method_config = lambda: base_api.ApiMethodInfo(
    613         http_method=u'PATCH',
    614         method_id=u'bigquery.tables.patch',
    615         ordered_params=[u'projectId', u'datasetId', u'tableId'],
    616         path_params=[u'datasetId', u'projectId', u'tableId'],
    617         query_params=[],
    618         relative_path=u'projects/{projectId}/datasets/{datasetId}/tables/{tableId}',
    619         request_field=u'table',
    620         request_type_name=u'BigqueryTablesPatchRequest',
    621         response_type_name=u'Table',
    622         supports_download=False,
    623     )
    624 
    625     def Update(self, request, global_params=None):
    626       """Updates information in an existing table. The update method replaces the entire table resource, whereas the patch method only replaces fields that are provided in the submitted table resource.
    627 
    628       Args:
    629         request: (BigqueryTablesUpdateRequest) input message
    630         global_params: (StandardQueryParameters, default: None) global arguments
    631       Returns:
    632         (Table) The response message.
    633       """
    634       config = self.GetMethodConfig('Update')
    635       return self._RunMethod(
    636           config, request, global_params=global_params)
    637 
    638     Update.method_config = lambda: base_api.ApiMethodInfo(
    639         http_method=u'PUT',
    640         method_id=u'bigquery.tables.update',
    641         ordered_params=[u'projectId', u'datasetId', u'tableId'],
    642         path_params=[u'datasetId', u'projectId', u'tableId'],
    643         query_params=[],
    644         relative_path=u'projects/{projectId}/datasets/{datasetId}/tables/{tableId}',
    645         request_field=u'table',
    646         request_type_name=u'BigqueryTablesUpdateRequest',
    647         response_type_name=u'Table',
    648         supports_download=False,
    649     )
    650