Add files using upload-large-folder tool

testbed/googleapis__python-bigquery/samples/CONTRIBUTING.md

@@ -0,0 +1 @@
+See https://github.com/GoogleCloudPlatform/python-docs-samples/blob/main/CONTRIBUTING.md

testbed/googleapis__python-bigquery/samples/add_empty_column.py

@@ -0,0 +1,40 @@
+# Copyright 2019 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+def add_empty_column(table_id: str) -> None:
+    # [START bigquery_add_empty_column]
+    from google.cloud import bigquery
+
+    # Construct a BigQuery client object.
+    client = bigquery.Client()
+
+    # TODO(developer): Set table_id to the ID of the table
+    #                  to add an empty column.
+    # table_id = "your-project.your_dataset.your_table_name"
+
+    table = client.get_table(table_id)  # Make an API request.
+
+    original_schema = table.schema
+    new_schema = original_schema[:]  # Creates a copy of the schema.
+    new_schema.append(bigquery.SchemaField("phone", "STRING"))
+
+    table.schema = new_schema
+    table = client.update_table(table, ["schema"])  # Make an API request.
+
+    if len(table.schema) == len(original_schema) + 1 == len(new_schema):
+        print("A new column has been added.")
+    else:
+        print("The column has not been added.")
+    # [END bigquery_add_empty_column]

testbed/googleapis__python-bigquery/samples/client_query_batch.py

@@ -0,0 +1,53 @@
+# Copyright 2019 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import typing
+
+if typing.TYPE_CHECKING:
+    from google.cloud import bigquery
+
+
+def client_query_batch() -> "bigquery.QueryJob":
+    # [START bigquery_query_batch]
+    from google.cloud import bigquery
+
+    # Construct a BigQuery client object.
+    client = bigquery.Client()
+
+    job_config = bigquery.QueryJobConfig(
+        # Run at batch priority, which won't count toward concurrent rate limit.
+        priority=bigquery.QueryPriority.BATCH
+    )
+
+    sql = """
+        SELECT corpus
+        FROM `bigquery-public-data.samples.shakespeare`
+        GROUP BY corpus;
+    """
+
+    # Start the query, passing in the extra configuration.
+    query_job = client.query(sql, job_config=job_config)  # Make an API request.
+
+    # Check on the progress by getting the job's updated state. Once the state
+    # is `DONE`, the results are ready.
+    query_job = typing.cast(
+        "bigquery.QueryJob",
+        client.get_job(
+            query_job.job_id, location=query_job.location
+        ),  # Make an API request.
+    )
+
+    print("Job {} is currently in state {}".format(query_job.job_id, query_job.state))
+    # [END bigquery_query_batch]
+    return query_job

testbed/googleapis__python-bigquery/samples/client_query_destination_table.py

@@ -0,0 +1,40 @@
+# Copyright 2019 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+def client_query_destination_table(table_id: str) -> None:
+    # [START bigquery_query_destination_table]
+    from google.cloud import bigquery
+
+    # Construct a BigQuery client object.
+    client = bigquery.Client()
+
+    # TODO(developer): Set table_id to the ID of the destination table.
+    # table_id = "your-project.your_dataset.your_table_name"
+
+    job_config = bigquery.QueryJobConfig(destination=table_id)
+
+    sql = """
+        SELECT corpus
+        FROM `bigquery-public-data.samples.shakespeare`
+        GROUP BY corpus;
+    """
+
+    # Start the query, passing in the extra configuration.
+    client.query_and_wait(
+        sql, job_config=job_config
+    )  # Make an API request and wait for the query to finish.
+
+    print("Query results loaded to the table {}".format(table_id))
+    # [END bigquery_query_destination_table]

testbed/googleapis__python-bigquery/samples/client_query_destination_table_clustered.py

@@ -0,0 +1,43 @@
+# Copyright 2020 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+def client_query_destination_table_clustered(table_id: str) -> None:
+    # [START bigquery_query_clustered_table]
+    from google.cloud import bigquery
+
+    # Construct a BigQuery client object.
+    client = bigquery.Client()
+
+    # TODO(developer): Set table_id to the ID of the destination table.
+    # table_id = "your-project.your_dataset.your_table_name"
+
+    sql = "SELECT * FROM `bigquery-public-data.samples.shakespeare`"
+    cluster_fields = ["corpus"]
+
+    job_config = bigquery.QueryJobConfig(
+        clustering_fields=cluster_fields, destination=table_id
+    )
+
+    # Start the query, passing in the extra configuration.
+    client.query_and_wait(
+        sql, job_config=job_config
+    )  # Make an API request and wait for job to complete.
+
+    table = client.get_table(table_id)  # Make an API request.
+    if table.clustering_fields == cluster_fields:
+        print(
+            "The destination table is written using the cluster_fields configuration."
+        )
+    # [END bigquery_query_clustered_table]

testbed/googleapis__python-bigquery/samples/client_query_destination_table_cmek.py

@@ -0,0 +1,48 @@
+# Copyright 2019 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+def client_query_destination_table_cmek(table_id: str, kms_key_name: str) -> None:
+    # [START bigquery_query_destination_table_cmek]
+    from google.cloud import bigquery
+
+    # Construct a BigQuery client object.
+    client = bigquery.Client()
+
+    # TODO(developer): Set table_id to the ID of the destination table.
+    # table_id = "your-project.your_dataset.your_table_name"
+
+    # Set the encryption key to use for the destination.
+    # TODO(developer): Replace this key with a key you have created in KMS.
+    # kms_key_name = "projects/{}/locations/{}/keyRings/{}/cryptoKeys/{}".format(
+    #     your-project, location, your-ring, your-key
+    # )
+
+    job_config = bigquery.QueryJobConfig(
+        destination=table_id,
+        destination_encryption_configuration=bigquery.EncryptionConfiguration(
+            kms_key_name=kms_key_name
+        ),
+    )
+
+    # Start the query, passing in the extra configuration.
+    query_job = client.query(
+        "SELECT 17 AS my_col;", job_config=job_config
+    )  # Make an API request.
+    query_job.result()  # Wait for the job to complete.
+
+    table = client.get_table(table_id)  # Make an API request.
+    if table.encryption_configuration.kms_key_name == kms_key_name:
+        print("The destination table is written using the encryption configuration")
+    # [END bigquery_query_destination_table_cmek]

testbed/googleapis__python-bigquery/samples/client_query_destination_table_legacy.py

@@ -0,0 +1,44 @@
+# Copyright 2019 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+def client_query_destination_table_legacy(table_id: str) -> None:
+    # [START bigquery_query_legacy_large_results]
+    from google.cloud import bigquery
+
+    # Construct a BigQuery client object.
+    client = bigquery.Client()
+
+    # TODO(developer): Set table_id to the ID of the destination table.
+    # table_id = "your-project.your_dataset.your_table_name"
+
+    # Set the destination table and use_legacy_sql to True to use
+    # legacy SQL syntax.
+    job_config = bigquery.QueryJobConfig(
+        allow_large_results=True, destination=table_id, use_legacy_sql=True
+    )
+
+    sql = """
+        SELECT corpus
+        FROM [bigquery-public-data:samples.shakespeare]
+        GROUP BY corpus;
+    """
+
+    # Start the query, passing in the extra configuration.
+    client.query_and_wait(
+        sql, job_config=job_config
+    )  # Make an API request and wait for the query to finish.
+
+    print("Query results loaded to the table {}".format(table_id))
+    # [END bigquery_query_legacy_large_results]

testbed/googleapis__python-bigquery/samples/client_query_dry_run.py

@@ -0,0 +1,44 @@
+# Copyright 2019 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import typing
+
+if typing.TYPE_CHECKING:
+    from google.cloud import bigquery
+
+
+def client_query_dry_run() -> "bigquery.QueryJob":
+    # [START bigquery_query_dry_run]
+    from google.cloud import bigquery
+
+    # Construct a BigQuery client object.
+    client = bigquery.Client()
+
+    job_config = bigquery.QueryJobConfig(dry_run=True, use_query_cache=False)
+
+    # Start the query, passing in the extra configuration.
+    query_job = client.query(
+        (
+            "SELECT name, COUNT(*) as name_count "
+            "FROM `bigquery-public-data.usa_names.usa_1910_2013` "
+            "WHERE state = 'WA' "
+            "GROUP BY name"
+        ),
+        job_config=job_config,
+    )  # Make an API request.
+
+    # A dry run query completes immediately.
+    print("This query will process {} bytes.".format(query_job.total_bytes_processed))
+    # [END bigquery_query_dry_run]
+    return query_job

testbed/googleapis__python-bigquery/samples/client_query_legacy_sql.py

@@ -0,0 +1,40 @@
+# Copyright 2019 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+def client_query_legacy_sql() -> None:
+    # [START bigquery_query_legacy]
+    from google.cloud import bigquery
+
+    # Construct a BigQuery client object.
+    client = bigquery.Client()
+
+    query = (
+        "SELECT name FROM [bigquery-public-data:usa_names.usa_1910_2013] "
+        'WHERE state = "TX" '
+        "LIMIT 100"
+    )
+
+    # Set use_legacy_sql to True to use legacy SQL syntax.
+    job_config = bigquery.QueryJobConfig(use_legacy_sql=True)
+
+    # Start the query and waits for query job to complete, passing in the extra configuration.
+    results = client.query_and_wait(
+        query, job_config=job_config
+    )  # Make an API request.
+
+    print("The query data:")
+    for row in results:
+        print(row)
+    # [END bigquery_query_legacy]

testbed/googleapis__python-bigquery/samples/client_query_shortmode.py

@@ -0,0 +1,53 @@
+# Copyright 2024 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+def client_query_shortmode() -> None:
+    # [START bigquery_query_shortquery]
+    # This example demonstrates issuing a query that may be run in short query mode.
+    #
+    # To enable the short query mode preview feature, the QUERY_PREVIEW_ENABLED
+    # environmental variable should be set to `TRUE`.
+    from google.cloud import bigquery
+
+    # Construct a BigQuery client object.
+    client = bigquery.Client()
+
+    query = """
+        SELECT
+            name,
+            gender,
+            SUM(number) AS total
+        FROM
+            bigquery-public-data.usa_names.usa_1910_2013
+        GROUP BY
+            name, gender
+        ORDER BY
+            total DESC
+        LIMIT 10
+    """
+    # Run the query.  The returned `rows` iterator can return information about
+    # how the query was executed as well as the result data.
+    rows = client.query_and_wait(query)
+
+    if rows.job_id is not None:
+        print("Query was run with job state.  Job ID: {}".format(rows.job_id))
+    else:
+        print("Query was run in short mode.  Query ID: {}".format(rows.query_id))
+
+    print("The query data:")
+    for row in rows:
+        # Row values can be accessed by field name or index.
+        print("name={}, gender={}, total={}".format(row[0], row[1], row["total"]))
+    # [END bigquery_query_shortquery]

testbed/googleapis__python-bigquery/samples/client_query_w_named_params.py

@@ -0,0 +1,42 @@
+# Copyright 2019 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+def client_query_w_named_params() -> None:
+    # [START bigquery_query_params_named]
+    from google.cloud import bigquery
+
+    # Construct a BigQuery client object.
+    client = bigquery.Client()
+
+    query = """
+        SELECT word, word_count
+        FROM `bigquery-public-data.samples.shakespeare`
+        WHERE corpus = @corpus
+        AND word_count >= @min_word_count
+        ORDER BY word_count DESC;
+    """
+    job_config = bigquery.QueryJobConfig(
+        query_parameters=[
+            bigquery.ScalarQueryParameter("corpus", "STRING", "romeoandjuliet"),
+            bigquery.ScalarQueryParameter("min_word_count", "INT64", 250),
+        ]
+    )
+    results = client.query_and_wait(
+        query, job_config=job_config
+    )  # Make an API request.
+
+    for row in results:
+        print("{}: \t{}".format(row.word, row.word_count))
+    # [END bigquery_query_params_named]

testbed/googleapis__python-bigquery/samples/client_query_w_positional_params.py

@@ -0,0 +1,44 @@
+# Copyright 2019 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+def client_query_w_positional_params() -> None:
+    # [START bigquery_query_params_positional]
+    from google.cloud import bigquery
+
+    # Construct a BigQuery client object.
+    client = bigquery.Client()
+
+    query = """
+        SELECT word, word_count
+        FROM `bigquery-public-data.samples.shakespeare`
+        WHERE corpus = ?
+        AND word_count >= ?
+        ORDER BY word_count DESC;
+    """
+    # Set the name to None to use positional parameters.
+    # Note that you cannot mix named and positional parameters.
+    job_config = bigquery.QueryJobConfig(
+        query_parameters=[
+            bigquery.ScalarQueryParameter(None, "STRING", "romeoandjuliet"),
+            bigquery.ScalarQueryParameter(None, "INT64", 250),
+        ]
+    )
+    results = client.query_and_wait(
+        query, job_config=job_config
+    )  # Make an API request.
+
+    for row in results:
+        print("{}: \t{}".format(row.word, row.word_count))
+    # [END bigquery_query_params_positional]

testbed/googleapis__python-bigquery/samples/client_query_w_struct_params.py

@@ -0,0 +1,39 @@
+# Copyright 2019 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+def client_query_w_struct_params() -> None:
+    # [START bigquery_query_params_structs]
+    from google.cloud import bigquery
+
+    # Construct a BigQuery client object.
+    client = bigquery.Client()
+
+    query = "SELECT @struct_value AS s;"
+    job_config = bigquery.QueryJobConfig(
+        query_parameters=[
+            bigquery.StructQueryParameter(
+                "struct_value",
+                bigquery.ScalarQueryParameter("x", "INT64", 1),
+                bigquery.ScalarQueryParameter("y", "STRING", "foo"),
+            )
+        ]
+    )
+    results = client.query_and_wait(
+        query, job_config=job_config
+    )  # Make an API request and waits for results.
+
+    for row in results:
+        print(row.s)
+    # [END bigquery_query_params_structs]

testbed/googleapis__python-bigquery/samples/client_query_w_timestamp_params.py

@@ -0,0 +1,41 @@
+# Copyright 2019 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+def client_query_w_timestamp_params() -> None:
+    # [START bigquery_query_params_timestamps]
+    import datetime
+
+    from google.cloud import bigquery
+
+    # Construct a BigQuery client object.
+    client = bigquery.Client()
+
+    query = "SELECT TIMESTAMP_ADD(@ts_value, INTERVAL 1 HOUR);"
+    job_config = bigquery.QueryJobConfig(
+        query_parameters=[
+            bigquery.ScalarQueryParameter(
+                "ts_value",
+                "TIMESTAMP",
+                datetime.datetime(2016, 12, 7, 8, 0, tzinfo=datetime.timezone.utc),
+            )
+        ]
+    )
+    results = client.query_and_wait(
+        query, job_config=job_config
+    )  # Make an API request.
+
+    for row in results:
+        print(row)
+    # [END bigquery_query_params_timestamps]

testbed/googleapis__python-bigquery/samples/copy_table.py

@@ -0,0 +1,34 @@
+# Copyright 2019 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+def copy_table(source_table_id: str, destination_table_id: str) -> None:
+    # [START bigquery_copy_table]
+
+    from google.cloud import bigquery
+
+    # Construct a BigQuery client object.
+    client = bigquery.Client()
+
+    # TODO(developer): Set source_table_id to the ID of the original table.
+    # source_table_id = "your-project.source_dataset.source_table"
+
+    # TODO(developer): Set destination_table_id to the ID of the destination table.
+    # destination_table_id = "your-project.destination_dataset.destination_table"
+
+    job = client.copy_table(source_table_id, destination_table_id)
+    job.result()  # Wait for the job to complete.
+
+    print("A copy of the table created.")
+    # [END bigquery_copy_table]

testbed/googleapis__python-bigquery/samples/copy_table_cmek.py

@@ -0,0 +1,46 @@
+# Copyright 2019 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+def copy_table_cmek(dest_table_id: str, orig_table_id: str, kms_key_name: str) -> None:
+    # [START bigquery_copy_table_cmek]
+    from google.cloud import bigquery
+
+    # Construct a BigQuery client object.
+    client = bigquery.Client()
+
+    # TODO(developer): Set dest_table_id to the ID of the destination table.
+    # dest_table_id = "your-project.your_dataset.your_table_name"
+
+    # TODO(developer): Set orig_table_id to the ID of the original table.
+    # orig_table_id = "your-project.your_dataset.your_table_name"
+
+    # Set the encryption key to use for the destination.
+    # TODO(developer): Replace this key with a key you have created in KMS.
+    # kms_key_name = "projects/{}/locations/{}/keyRings/{}/cryptoKeys/{}".format(
+    #     your-project, location, your-ring, your-key
+    # )
+
+    job_config = bigquery.CopyJobConfig(
+        destination_encryption_configuration=bigquery.EncryptionConfiguration(
+            kms_key_name=kms_key_name
+        )
+    )
+    job = client.copy_table(orig_table_id, dest_table_id, job_config=job_config)
+    job.result()  # Wait for the job to complete.
+
+    dest_table = client.get_table(dest_table_id)  # Make an API request.
+    if dest_table.encryption_configuration.kms_key_name == kms_key_name:
+        print("A copy of the table created")
+    # [END bigquery_copy_table_cmek]

testbed/googleapis__python-bigquery/samples/copy_table_multiple_source.py

@@ -0,0 +1,36 @@
+# Copyright 2019 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from typing import Sequence
+
+
+def copy_table_multiple_source(dest_table_id: str, table_ids: Sequence[str]) -> None:
+    # [START bigquery_copy_table_multiple_source]
+
+    from google.cloud import bigquery
+
+    # Construct a BigQuery client object.
+    client = bigquery.Client()
+
+    # TODO(developer): Set dest_table_id to the ID of the destination table.
+    # dest_table_id = "your-project.your_dataset.your_table_name"
+
+    # TODO(developer): Set table_ids to the list of the IDs of the original tables.
+    # table_ids = ["your-project.your_dataset.your_table_name", ...]
+
+    job = client.copy_table(table_ids, dest_table_id)  # Make an API request.
+    job.result()  # Wait for the job to complete.
+
+    print("The tables {} have been appended to {}".format(table_ids, dest_table_id))
+    # [END bigquery_copy_table_multiple_source]

testbed/googleapis__python-bigquery/samples/create_dataset.py

@@ -0,0 +1,37 @@
+# Copyright 2019 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+def create_dataset(dataset_id: str) -> None:
+    # [START bigquery_create_dataset]
+    from google.cloud import bigquery
+
+    # Construct a BigQuery client object.
+    client = bigquery.Client()
+
+    # TODO(developer): Set dataset_id to the ID of the dataset to create.
+    # dataset_id = "{}.your_dataset".format(client.project)
+
+    # Construct a full Dataset object to send to the API.
+    dataset = bigquery.Dataset(dataset_id)
+
+    # TODO(developer): Specify the geographic location where the dataset should reside.
+    dataset.location = "US"
+
+    # Send the dataset to the API for creation, with an explicit timeout.
+    # Raises google.api_core.exceptions.Conflict if the Dataset already
+    # exists within the project.
+    dataset = client.create_dataset(dataset, timeout=30)  # Make an API request.
+    print("Created dataset {}.{}".format(client.project, dataset.dataset_id))
+    # [END bigquery_create_dataset]

testbed/googleapis__python-bigquery/samples/create_job.py

@@ -0,0 +1,66 @@
+# Copyright 2019 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import typing
+from typing import Union
+
+if typing.TYPE_CHECKING:
+    from google.cloud.bigquery import LoadJob, CopyJob, ExtractJob, QueryJob
+
+
+def create_job() -> "Union[LoadJob, CopyJob, ExtractJob, QueryJob]":
+    # [START bigquery_create_job]
+    from google.cloud import bigquery
+
+    # Construct a BigQuery client object.
+    client = bigquery.Client()
+
+    query_job = client.create_job(
+        # Specify a job configuration, providing a query
+        # and/or optional job resource properties, as needed.
+        # The job instance can be a LoadJob, CopyJob, ExtractJob, QueryJob
+        # Here, we demonstrate a "query" job.
+        # References:
+        #     https://googleapis.dev/python/bigquery/latest/generated/google.cloud.bigquery.client.Client.html#google.cloud.bigquery.client.Client.create_job
+        #     https://cloud.google.com/bigquery/docs/reference/rest/v2/Job
+        #
+        # Example use cases for .create_job() include:
+        #    * to retry failed jobs
+        #    * to generate jobs with an experimental API property that hasn't
+        #      been added to one of the manually written job configuration
+        #      classes yet
+        #
+        # NOTE: unless it is necessary to create a job in this way, the
+        # preferred approach is to use one of the dedicated API calls:
+        #   client.query()
+        #   client.extract_table()
+        #   client.copy_table()
+        #   client.load_table_file(), client.load_table_from_dataframe(), etc
+        job_config={
+            "query": {
+                "query": """
+                         SELECT country_name
+                         FROM `bigquery-public-data.utility_us.country_code_iso`
+                         LIMIT 5
+                         """,
+            },
+            "labels": {"example-label": "example-value"},
+            "maximum_bytes_billed": 10000000,
+        }
+    )  # Make an API request.
+
+    print(f"Started job: {query_job.job_id}")
+    # [END bigquery_create_job]
+
+    return query_job

testbed/googleapis__python-bigquery/samples/create_routine.py

@@ -0,0 +1,50 @@
+# Copyright 2019 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import typing
+
+if typing.TYPE_CHECKING:
+    from google.cloud import bigquery
+
+
+def create_routine(routine_id: str) -> "bigquery.Routine":
+    # [START bigquery_create_routine]
+    from google.cloud import bigquery
+
+    # Construct a BigQuery client object.
+    client = bigquery.Client()
+
+    # TODO(developer): Choose a fully qualified ID for the routine.
+    # routine_id = "my-project.my_dataset.my_routine"
+
+    routine = bigquery.Routine(
+        routine_id,
+        type_="SCALAR_FUNCTION",
+        language="SQL",
+        body="x * 3",
+        arguments=[
+            bigquery.RoutineArgument(
+                name="x",
+                data_type=bigquery.StandardSqlDataType(
+                    type_kind=bigquery.StandardSqlTypeNames.INT64
+                ),
+            )
+        ],
+    )
+
+    routine = client.create_routine(routine)  # Make an API request.
+
+    print("Created routine {}".format(routine.reference))
+    # [END bigquery_create_routine]
+    return routine

testbed/googleapis__python-bigquery/samples/create_routine_ddl.py

@@ -0,0 +1,40 @@
+# Copyright 2019 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+def create_routine_ddl(routine_id: str) -> None:
+    # [START bigquery_create_routine_ddl]
+
+    from google.cloud import bigquery
+
+    # Construct a BigQuery client object.
+    client = bigquery.Client()
+
+    # TODO(developer): Choose a fully-qualified ID for the routine.
+    # routine_id = "my-project.my_dataset.my_routine"
+
+    sql = """
+    CREATE FUNCTION `{}`(
+        arr ARRAY<STRUCT<name STRING, val INT64>>
+    ) AS (
+        (SELECT SUM(IF(elem.name = "foo",elem.val,null)) FROM UNNEST(arr) AS elem)
+    )
+    """.format(
+        routine_id
+    )
+    query_job = client.query(sql)  # Make an API request.
+    query_job.result()  # Wait for the job to complete.
+
+    print("Created routine {}".format(query_job.ddl_target_routine))
+    # [END bigquery_create_routine_ddl]

testbed/googleapis__python-bigquery/samples/create_table.py

@@ -0,0 +1,36 @@
+# Copyright 2019 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+def create_table(table_id: str) -> None:
+    # [START bigquery_create_table]
+    from google.cloud import bigquery
+
+    # Construct a BigQuery client object.
+    client = bigquery.Client()
+
+    # TODO(developer): Set table_id to the ID of the table to create.
+    # table_id = "your-project.your_dataset.your_table_name"
+
+    schema = [
+        bigquery.SchemaField("full_name", "STRING", mode="REQUIRED"),
+        bigquery.SchemaField("age", "INTEGER", mode="REQUIRED"),
+    ]
+
+    table = bigquery.Table(table_id, schema=schema)
+    table = client.create_table(table)  # Make an API request.
+    print(
+        "Created table {}.{}.{}".format(table.project, table.dataset_id, table.table_id)
+    )
+    # [END bigquery_create_table]

testbed/googleapis__python-bigquery/samples/create_table_clustered.py

@@ -0,0 +1,46 @@
+# Copyright 2019 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import typing
+
+if typing.TYPE_CHECKING:
+    from google.cloud import bigquery
+
+
+def create_table_clustered(table_id: str) -> "bigquery.Table":
+    # [START bigquery_create_table_clustered]
+    from google.cloud import bigquery
+
+    # Construct a BigQuery client object.
+    client = bigquery.Client()
+
+    # TODO(developer): Set table_id to the ID of the table to create.
+    # table_id = "your-project.your_dataset.your_table_name"
+
+    schema = [
+        bigquery.SchemaField("full_name", "STRING"),
+        bigquery.SchemaField("city", "STRING"),
+        bigquery.SchemaField("zipcode", "INTEGER"),
+    ]
+
+    table = bigquery.Table(table_id, schema=schema)
+    table.clustering_fields = ["city", "zipcode"]
+    table = client.create_table(table)  # Make an API request.
+    print(
+        "Created clustered table {}.{}.{}".format(
+            table.project, table.dataset_id, table.table_id
+        )
+    )
+    # [END bigquery_create_table_clustered]
+    return table

testbed/googleapis__python-bigquery/samples/create_table_range_partitioned.py

@@ -0,0 +1,49 @@
+# Copyright 2019 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import typing
+
+if typing.TYPE_CHECKING:
+    from google.cloud import bigquery
+
+
+def create_table_range_partitioned(table_id: str) -> "bigquery.Table":
+    # [START bigquery_create_table_range_partitioned]
+    from google.cloud import bigquery
+
+    # Construct a BigQuery client object.
+    client = bigquery.Client()
+
+    # TODO(developer): Set table_id to the ID of the table to create.
+    # table_id = "your-project.your_dataset.your_table_name"
+
+    schema = [
+        bigquery.SchemaField("full_name", "STRING"),
+        bigquery.SchemaField("city", "STRING"),
+        bigquery.SchemaField("zipcode", "INTEGER"),
+    ]
+
+    table = bigquery.Table(table_id, schema=schema)
+    table.range_partitioning = bigquery.RangePartitioning(
+        # To use integer range partitioning, select a top-level REQUIRED /
+        # NULLABLE column with INTEGER / INT64 data type.
+        field="zipcode",
+        range_=bigquery.PartitionRange(start=0, end=100000, interval=10),
+    )
+    table = client.create_table(table)  # Make an API request.
+    print(
+        "Created table {}.{}.{}".format(table.project, table.dataset_id, table.table_id)
+    )
+    # [END bigquery_create_table_range_partitioned]
+    return table

testbed/googleapis__python-bigquery/samples/dataset_exists.py

@@ -0,0 +1,31 @@
+# Copyright 2019 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+def dataset_exists(dataset_id: str) -> None:
+    # [START bigquery_dataset_exists]
+    from google.cloud import bigquery
+    from google.cloud.exceptions import NotFound
+
+    client = bigquery.Client()
+
+    # TODO(developer): Set dataset_id to the ID of the dataset to determine existence.
+    # dataset_id = "your-project.your_dataset"
+
+    try:
+        client.get_dataset(dataset_id)  # Make an API request.
+        print("Dataset {} already exists".format(dataset_id))
+    except NotFound:
+        print("Dataset {} is not found".format(dataset_id))
+    # [END bigquery_dataset_exists]

testbed/googleapis__python-bigquery/samples/delete_dataset.py

@@ -0,0 +1,34 @@
+# Copyright 2019 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+def delete_dataset(dataset_id: str) -> None:
+    # [START bigquery_delete_dataset]
+
+    from google.cloud import bigquery
+
+    # Construct a BigQuery client object.
+    client = bigquery.Client()
+
+    # TODO(developer): Set model_id to the ID of the model to fetch.
+    # dataset_id = 'your-project.your_dataset'
+
+    # Use the delete_contents parameter to delete a dataset and its contents.
+    # Use the not_found_ok parameter to not receive an error if the dataset has already been deleted.
+    client.delete_dataset(
+        dataset_id, delete_contents=True, not_found_ok=True
+    )  # Make an API request.
+
+    print("Deleted dataset '{}'.".format(dataset_id))
+    # [END bigquery_delete_dataset]

testbed/googleapis__python-bigquery/samples/delete_dataset_labels.py

@@ -0,0 +1,40 @@
+# Copyright 2019 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import typing
+
+if typing.TYPE_CHECKING:
+    from google.cloud import bigquery
+
+
+def delete_dataset_labels(dataset_id: str) -> "bigquery.Dataset":
+    # [START bigquery_delete_label_dataset]
+
+    from google.cloud import bigquery
+
+    # Construct a BigQuery client object.
+    client = bigquery.Client()
+
+    # TODO(developer): Set dataset_id to the ID of the dataset to fetch.
+    # dataset_id = "your-project.your_dataset"
+
+    dataset = client.get_dataset(dataset_id)  # Make an API request.
+
+    # To delete a label from a dataset, set its value to None.
+    dataset.labels["color"] = None
+
+    dataset = client.update_dataset(dataset, ["labels"])  # Make an API request.
+    print("Labels deleted from {}".format(dataset_id))
+    # [END bigquery_delete_label_dataset]
+    return dataset

testbed/googleapis__python-bigquery/samples/delete_model.py

@@ -0,0 +1,32 @@
+# Copyright 2019 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+def delete_model(model_id: str) -> None:
+    """Sample ID: go/samples-tracker/1534"""
+
+    # [START bigquery_delete_model]
+
+    from google.cloud import bigquery
+
+    # Construct a BigQuery client object.
+    client = bigquery.Client()
+
+    # TODO(developer): Set model_id to the ID of the model to fetch.
+    # model_id = 'your-project.your_dataset.your_model'
+
+    client.delete_model(model_id)  # Make an API request.
+
+    print("Deleted model '{}'.".format(model_id))
+    # [END bigquery_delete_model]

testbed/googleapis__python-bigquery/samples/delete_routine.py

@@ -0,0 +1,30 @@
+# Copyright 2019 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+def delete_routine(routine_id: str) -> None:
+    # [START bigquery_delete_routine]
+
+    from google.cloud import bigquery
+
+    # Construct a BigQuery client object.
+    client = bigquery.Client()
+
+    # TODO(developer): Set the fully-qualified ID for the routine.
+    # routine_id = "my-project.my_dataset.my_routine"
+
+    client.delete_routine(routine_id)  # Make an API request.
+
+    print("Deleted routine {}.".format(routine_id))
+    # [END bigquery_delete_routine]

testbed/googleapis__python-bigquery/samples/delete_table.py

@@ -0,0 +1,31 @@
+# Copyright 2019 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+def delete_table(table_id: str) -> None:
+    # [START bigquery_delete_table]
+
+    from google.cloud import bigquery
+
+    # Construct a BigQuery client object.
+    client = bigquery.Client()
+
+    # TODO(developer): Set table_id to the ID of the table to fetch.
+    # table_id = 'your-project.your_dataset.your_table'
+
+    # If the table does not exist, delete_table raises
+    # google.api_core.exceptions.NotFound unless not_found_ok is True.
+    client.delete_table(table_id, not_found_ok=True)  # Make an API request.
+    print("Deleted table '{}'.".format(table_id))
+    # [END bigquery_delete_table]

testbed/googleapis__python-bigquery/samples/download_public_data.py

@@ -0,0 +1,32 @@
+# Copyright 2019 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+def download_public_data() -> None:
+    # [START bigquery_pandas_public_data]
+
+    from google.cloud import bigquery
+
+    # Construct a BigQuery client object.
+    client = bigquery.Client()
+
+    # TODO(developer): Set table_id to the fully-qualified table ID in standard
+    # SQL format, including the project ID and dataset ID.
+    table_id = "bigquery-public-data.usa_names.usa_1910_current"
+
+    # Use the BigQuery Storage API to speed-up downloads of large tables.
+    dataframe = client.list_rows(table_id).to_dataframe(create_bqstorage_client=True)
+
+    print(dataframe.info())
+    # [END bigquery_pandas_public_data]

testbed/googleapis__python-bigquery/samples/download_public_data_sandbox.py

@@ -0,0 +1,35 @@
+# Copyright 2019 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+def download_public_data_sandbox() -> None:
+    # [START bigquery_pandas_public_data_sandbox]
+
+    from google.cloud import bigquery
+
+    # Construct a BigQuery client object.
+    client = bigquery.Client()
+
+    # `SELECT *` is an anti-pattern in BigQuery because it is cheaper and
+    # faster to use the BigQuery Storage API directly, but BigQuery Sandbox
+    # users can only use the BigQuery Storage API to download query results.
+    query_string = "SELECT * FROM `bigquery-public-data.usa_names.usa_1910_current`"
+
+    # Use the BigQuery Storage API to speed-up downloads of large tables.
+    dataframe = client.query_and_wait(query_string).to_dataframe(
+        create_bqstorage_client=True
+    )
+
+    print(dataframe.info())
+    # [END bigquery_pandas_public_data_sandbox]

testbed/googleapis__python-bigquery/samples/get_dataset.py

@@ -0,0 +1,55 @@
+# Copyright 2019 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+def get_dataset(dataset_id: str) -> None:
+    # [START bigquery_get_dataset]
+
+    from google.cloud import bigquery
+
+    # Construct a BigQuery client object.
+    client = bigquery.Client()
+
+    # TODO(developer): Set dataset_id to the ID of the dataset to fetch.
+    # dataset_id = 'your-project.your_dataset'
+
+    dataset = client.get_dataset(dataset_id)  # Make an API request.
+
+    full_dataset_id = "{}.{}".format(dataset.project, dataset.dataset_id)
+    friendly_name = dataset.friendly_name
+    print(
+        "Got dataset '{}' with friendly_name '{}'.".format(
+            full_dataset_id, friendly_name
+        )
+    )
+
+    # View dataset properties.
+    print("Description: {}".format(dataset.description))
+    print("Labels:")
+    labels = dataset.labels
+    if labels:
+        for label, value in labels.items():
+            print("\t{}: {}".format(label, value))
+    else:
+        print("\tDataset has no labels defined.")
+
+    # View tables in dataset.
+    print("Tables:")
+    tables = list(client.list_tables(dataset))  # Make an API request(s).
+    if tables:
+        for table in tables:
+            print("\t{}".format(table.table_id))
+    else:
+        print("\tThis dataset does not contain any tables.")
+    # [END bigquery_get_dataset]

testbed/googleapis__python-bigquery/samples/get_dataset_labels.py

@@ -0,0 +1,37 @@
+# Copyright 2019 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+def get_dataset_labels(dataset_id: str) -> None:
+    # [START bigquery_get_dataset_labels]
+
+    from google.cloud import bigquery
+
+    # Construct a BigQuery client object.
+    client = bigquery.Client()
+
+    # TODO(developer): Set dataset_id to the ID of the dataset to fetch.
+    # dataset_id = "your-project.your_dataset"
+
+    dataset = client.get_dataset(dataset_id)  # Make an API request.
+
+    # View dataset labels.
+    print("Dataset ID: {}".format(dataset_id))
+    print("Labels:")
+    if dataset.labels:
+        for label, value in dataset.labels.items():
+            print("\t{}: {}".format(label, value))
+    else:
+        print("\tDataset has no labels defined.")
+    # [END bigquery_get_dataset_labels]

testbed/googleapis__python-bigquery/samples/get_model.py

@@ -0,0 +1,36 @@
+# Copyright 2019 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+def get_model(model_id: str) -> None:
+    """Sample ID: go/samples-tracker/1510"""
+
+    # [START bigquery_get_model]
+
+    from google.cloud import bigquery
+
+    # Construct a BigQuery client object.
+    client = bigquery.Client()
+
+    # TODO(developer): Set model_id to the ID of the model to fetch.
+    # model_id = 'your-project.your_dataset.your_model'
+
+    model = client.get_model(model_id)  # Make an API request.
+
+    full_model_id = "{}.{}.{}".format(model.project, model.dataset_id, model.model_id)
+    friendly_name = model.friendly_name
+    print(
+        "Got model '{}' with friendly_name '{}'.".format(full_model_id, friendly_name)
+    )
+    # [END bigquery_get_model]

testbed/googleapis__python-bigquery/samples/get_routine.py

@@ -0,0 +1,43 @@
+# Copyright 2019 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import typing
+
+if typing.TYPE_CHECKING:
+    from google.cloud import bigquery
+
+
+def get_routine(routine_id: str) -> "bigquery.Routine":
+    # [START bigquery_get_routine]
+
+    from google.cloud import bigquery
+
+    # Construct a BigQuery client object.
+    client = bigquery.Client()
+
+    # TODO(developer): Set the fully-qualified ID for the routine.
+    # routine_id = "my-project.my_dataset.my_routine"
+
+    routine = client.get_routine(routine_id)  # Make an API request.
+
+    print("Routine '{}':".format(routine.reference))
+    print("\tType: '{}'".format(routine.type_))
+    print("\tLanguage: '{}'".format(routine.language))
+    print("\tArguments:")
+
+    for argument in routine.arguments:
+        print("\t\tName: '{}'".format(argument.name))
+        print("\t\tType: '{}'".format(argument.data_type))
+    # [END bigquery_get_routine]
+    return routine

testbed/googleapis__python-bigquery/samples/get_table.py

@@ -0,0 +1,36 @@
+# Copyright 2019 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+def get_table(table_id: str) -> None:
+    # [START bigquery_get_table]
+
+    from google.cloud import bigquery
+
+    # Construct a BigQuery client object.
+    client = bigquery.Client()
+
+    # TODO(developer): Set table_id to the ID of the model to fetch.
+    # table_id = 'your-project.your_dataset.your_table'
+
+    table = client.get_table(table_id)  # Make an API request.
+
+    # View table properties
+    print(
+        "Got table '{}.{}.{}'.".format(table.project, table.dataset_id, table.table_id)
+    )
+    print("Table schema: {}".format(table.schema))
+    print("Table description: {}".format(table.description))
+    print("Table has {} rows".format(table.num_rows))
+    # [END bigquery_get_table]

testbed/googleapis__python-bigquery/samples/label_dataset.py

@@ -0,0 +1,32 @@
+# Copyright 2019 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+def label_dataset(dataset_id: str) -> None:
+    # [START bigquery_label_dataset]
+
+    from google.cloud import bigquery
+
+    # Construct a BigQuery client object.
+    client = bigquery.Client()
+
+    # TODO(developer): Set dataset_id to the ID of the dataset to fetch.
+    # dataset_id = "your-project.your_dataset"
+
+    dataset = client.get_dataset(dataset_id)  # Make an API request.
+    dataset.labels = {"color": "green"}
+    dataset = client.update_dataset(dataset, ["labels"])  # Make an API request.
+
+    print("Labels added to {}".format(dataset_id))
+    # [END bigquery_label_dataset]

testbed/googleapis__python-bigquery/samples/list_datasets.py

@@ -0,0 +1,33 @@
+# Copyright 2019 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+def list_datasets() -> None:
+    # [START bigquery_list_datasets]
+
+    from google.cloud import bigquery
+
+    # Construct a BigQuery client object.
+    client = bigquery.Client()
+
+    datasets = list(client.list_datasets())  # Make an API request.
+    project = client.project
+
+    if datasets:
+        print("Datasets in project {}:".format(project))
+        for dataset in datasets:
+            print("\t{}".format(dataset.dataset_id))
+    else:
+        print("{} project does not contain any datasets.".format(project))
+    # [END bigquery_list_datasets]

testbed/googleapis__python-bigquery/samples/list_datasets_by_label.py

@@ -0,0 +1,33 @@
+# Copyright 2019 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+def list_datasets_by_label() -> None:
+    # [START bigquery_list_datasets_by_label]
+
+    from google.cloud import bigquery
+
+    # Construct a BigQuery client object.
+    client = bigquery.Client()
+
+    label_filter = "labels.color:green"
+    datasets = list(client.list_datasets(filter=label_filter))  # Make an API request.
+
+    if datasets:
+        print("Datasets filtered by {}:".format(label_filter))
+        for dataset in datasets:
+            print("\t{}.{}".format(dataset.project, dataset.dataset_id))
+    else:
+        print("No datasets found with this filter.")
+    # [END bigquery_list_datasets_by_label]

testbed/googleapis__python-bigquery/samples/list_models.py

@@ -0,0 +1,39 @@
+# Copyright 2019 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+def list_models(dataset_id: str) -> None:
+    """Sample ID: go/samples-tracker/1512"""
+
+    # [START bigquery_list_models]
+
+    from google.cloud import bigquery
+
+    # Construct a BigQuery client object.
+    client = bigquery.Client()
+
+    # TODO(developer): Set dataset_id to the ID of the dataset that contains
+    #                  the models you are listing.
+    # dataset_id = 'your-project.your_dataset'
+
+    models = client.list_models(dataset_id)  # Make an API request.
+
+    print("Models contained in '{}':".format(dataset_id))
+    for model in models:
+        full_model_id = "{}.{}.{}".format(
+            model.project, model.dataset_id, model.model_id
+        )
+        friendly_name = model.friendly_name
+        print("{}: friendly_name='{}'".format(full_model_id, friendly_name))
+    # [END bigquery_list_models]

testbed/googleapis__python-bigquery/samples/list_routines.py

@@ -0,0 +1,33 @@
+# Copyright 2019 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+def list_routines(dataset_id: str) -> None:
+    # [START bigquery_list_routines]
+
+    from google.cloud import bigquery
+
+    # Construct a BigQuery client object.
+    client = bigquery.Client()
+
+    # TODO(developer): Set dataset_id to the ID of the dataset that contains
+    #                  the routines you are listing.
+    # dataset_id = 'your-project.your_dataset'
+
+    routines = client.list_routines(dataset_id)  # Make an API request.
+
+    print("Routines contained in dataset {}:".format(dataset_id))
+    for routine in routines:
+        print(routine.reference)
+    # [END bigquery_list_routines]

testbed/googleapis__python-bigquery/samples/list_tables.py

@@ -0,0 +1,33 @@
+# Copyright 2019 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+def list_tables(dataset_id: str) -> None:
+    # [START bigquery_list_tables]
+
+    from google.cloud import bigquery
+
+    # Construct a BigQuery client object.
+    client = bigquery.Client()
+
+    # TODO(developer): Set dataset_id to the ID of the dataset that contains
+    #                  the tables you are listing.
+    # dataset_id = 'your-project.your_dataset'
+
+    tables = client.list_tables(dataset_id)  # Make an API request.
+
+    print("Tables contained in '{}':".format(dataset_id))
+    for table in tables:
+        print("{}.{}.{}".format(table.project, table.dataset_id, table.table_id))
+    # [END bigquery_list_tables]

testbed/googleapis__python-bigquery/samples/load_table_clustered.py

@@ -0,0 +1,59 @@
+# Copyright 2020 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import typing
+
+if typing.TYPE_CHECKING:
+    from google.cloud import bigquery
+
+
+def load_table_clustered(table_id: str) -> "bigquery.Table":
+    # [START bigquery_load_table_clustered]
+    from google.cloud import bigquery
+
+    # Construct a BigQuery client object.
+    client = bigquery.Client()
+
+    # TODO(developer): Set table_id to the ID of the table to create.
+    # table_id = "your-project.your_dataset.your_table_name"
+
+    job_config = bigquery.LoadJobConfig(
+        skip_leading_rows=1,
+        source_format=bigquery.SourceFormat.CSV,
+        schema=[
+            bigquery.SchemaField("timestamp", bigquery.SqlTypeNames.TIMESTAMP),
+            bigquery.SchemaField("origin", bigquery.SqlTypeNames.STRING),
+            bigquery.SchemaField("destination", bigquery.SqlTypeNames.STRING),
+            bigquery.SchemaField("amount", bigquery.SqlTypeNames.NUMERIC),
+        ],
+        time_partitioning=bigquery.TimePartitioning(field="timestamp"),
+        clustering_fields=["origin", "destination"],
+    )
+
+    job = client.load_table_from_uri(
+        ["gs://cloud-samples-data/bigquery/sample-transactions/transactions.csv"],
+        table_id,
+        job_config=job_config,
+    )
+
+    job.result()  # Waits for the job to complete.
+
+    table = client.get_table(table_id)  # Make an API request.
+    print(
+        "Loaded {} rows and {} columns to {}".format(
+            table.num_rows, len(table.schema), table_id
+        )
+    )
+    # [END bigquery_load_table_clustered]
+    return table

testbed/googleapis__python-bigquery/samples/load_table_dataframe.py

@@ -0,0 +1,120 @@
+# Copyright 2019 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import typing
+
+if typing.TYPE_CHECKING:
+    from google.cloud import bigquery
+
+
+def load_table_dataframe(table_id: str) -> "bigquery.Table":
+    # [START bigquery_load_table_dataframe]
+    import datetime
+
+    from google.cloud import bigquery
+    import pandas
+    import pytz
+
+    # Construct a BigQuery client object.
+    client = bigquery.Client()
+
+    # TODO(developer): Set table_id to the ID of the table to create.
+    # table_id = "your-project.your_dataset.your_table_name"
+
+    records = [
+        {
+            "title": "The Meaning of Life",
+            "release_year": 1983,
+            "length_minutes": 112.5,
+            "release_date": pytz.timezone("Europe/Paris")
+            .localize(datetime.datetime(1983, 5, 9, 13, 0, 0))
+            .astimezone(pytz.utc),
+            # Assume UTC timezone when a datetime object contains no timezone.
+            "dvd_release": datetime.datetime(2002, 1, 22, 7, 0, 0),
+        },
+        {
+            "title": "Monty Python and the Holy Grail",
+            "release_year": 1975,
+            "length_minutes": 91.5,
+            "release_date": pytz.timezone("Europe/London")
+            .localize(datetime.datetime(1975, 4, 9, 23, 59, 2))
+            .astimezone(pytz.utc),
+            "dvd_release": datetime.datetime(2002, 7, 16, 9, 0, 0),
+        },
+        {
+            "title": "Life of Brian",
+            "release_year": 1979,
+            "length_minutes": 94.25,
+            "release_date": pytz.timezone("America/New_York")
+            .localize(datetime.datetime(1979, 8, 17, 23, 59, 5))
+            .astimezone(pytz.utc),
+            "dvd_release": datetime.datetime(2008, 1, 14, 8, 0, 0),
+        },
+        {
+            "title": "And Now for Something Completely Different",
+            "release_year": 1971,
+            "length_minutes": 88.0,
+            "release_date": pytz.timezone("Europe/London")
+            .localize(datetime.datetime(1971, 9, 28, 23, 59, 7))
+            .astimezone(pytz.utc),
+            "dvd_release": datetime.datetime(2003, 10, 22, 10, 0, 0),
+        },
+    ]
+    dataframe = pandas.DataFrame(
+        records,
+        # In the loaded table, the column order reflects the order of the
+        # columns in the DataFrame.
+        columns=[
+            "title",
+            "release_year",
+            "length_minutes",
+            "release_date",
+            "dvd_release",
+        ],
+        # Optionally, set a named index, which can also be written to the
+        # BigQuery table.
+        index=pandas.Index(
+            ["Q24980", "Q25043", "Q24953", "Q16403"], name="wikidata_id"
+        ),
+    )
+    job_config = bigquery.LoadJobConfig(
+        # Specify a (partial) schema. All columns are always written to the
+        # table. The schema is used to assist in data type definitions.
+        schema=[
+            # Specify the type of columns whose type cannot be auto-detected. For
+            # example the "title" column uses pandas dtype "object", so its
+            # data type is ambiguous.
+            bigquery.SchemaField("title", bigquery.enums.SqlTypeNames.STRING),
+            # Indexes are written if included in the schema by name.
+            bigquery.SchemaField("wikidata_id", bigquery.enums.SqlTypeNames.STRING),
+        ],
+        # Optionally, set the write disposition. BigQuery appends loaded rows
+        # to an existing table by default, but with WRITE_TRUNCATE write
+        # disposition it replaces the table with the loaded data.
+        write_disposition="WRITE_TRUNCATE",
+    )
+
+    job = client.load_table_from_dataframe(
+        dataframe, table_id, job_config=job_config
+    )  # Make an API request.
+    job.result()  # Wait for the job to complete.
+
+    table = client.get_table(table_id)  # Make an API request.
+    print(
+        "Loaded {} rows and {} columns to {}".format(
+            table.num_rows, len(table.schema), table_id
+        )
+    )
+    # [END bigquery_load_table_dataframe]
+    return table

testbed/googleapis__python-bigquery/samples/load_table_file.py

@@ -0,0 +1,49 @@
+# Copyright 2020 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import typing
+
+if typing.TYPE_CHECKING:
+    from google.cloud import bigquery
+
+
+def load_table_file(file_path: str, table_id: str) -> "bigquery.Table":
+    # [START bigquery_load_from_file]
+    from google.cloud import bigquery
+
+    # Construct a BigQuery client object.
+    client = bigquery.Client()
+
+    # TODO(developer): Set table_id to the ID of the table to create.
+    # table_id = "your-project.your_dataset.your_table_name"
+
+    job_config = bigquery.LoadJobConfig(
+        source_format=bigquery.SourceFormat.CSV,
+        skip_leading_rows=1,
+        autodetect=True,
+    )
+
+    with open(file_path, "rb") as source_file:
+        job = client.load_table_from_file(source_file, table_id, job_config=job_config)
+
+    job.result()  # Waits for the job to complete.
+
+    table = client.get_table(table_id)  # Make an API request.
+    print(
+        "Loaded {} rows and {} columns to {}".format(
+            table.num_rows, len(table.schema), table_id
+        )
+    )
+    # [END bigquery_load_from_file]
+    return table

testbed/googleapis__python-bigquery/samples/load_table_uri_autodetect_csv.py

@@ -0,0 +1,44 @@
+# Copyright 2020 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+def load_table_uri_autodetect_csv(table_id: str) -> None:
+    # [START bigquery_load_table_gcs_csv_autodetect]
+    from google.cloud import bigquery
+
+    # Construct a BigQuery client object.
+    client = bigquery.Client()
+
+    # TODO(developer): Set table_id to the ID of the table to create.
+    # table_id = "your-project.your_dataset.your_table_name
+
+    # Set the encryption key to use for the destination.
+    # TODO: Replace this key with a key you have created in KMS.
+    # kms_key_name = "projects/{}/locations/{}/keyRings/{}/cryptoKeys/{}".format(
+    #     "cloud-samples-tests", "us", "test", "test"
+    # )
+    job_config = bigquery.LoadJobConfig(
+        autodetect=True,
+        skip_leading_rows=1,
+        # The source format defaults to CSV, so the line below is optional.
+        source_format=bigquery.SourceFormat.CSV,
+    )
+    uri = "gs://cloud-samples-data/bigquery/us-states/us-states.csv"
+    load_job = client.load_table_from_uri(
+        uri, table_id, job_config=job_config
+    )  # Make an API request.
+    load_job.result()  # Waits for the job to complete.
+    destination_table = client.get_table(table_id)
+    print("Loaded {} rows.".format(destination_table.num_rows))
+    # [END bigquery_load_table_gcs_csv_autodetect]

testbed/googleapis__python-bigquery/samples/load_table_uri_autodetect_json.py

@@ -0,0 +1,41 @@
+# Copyright 2020 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+def load_table_uri_autodetect_json(table_id: str) -> None:
+    # [START bigquery_load_table_gcs_json_autodetect]
+    from google.cloud import bigquery
+
+    # Construct a BigQuery client object.
+    client = bigquery.Client()
+
+    # TODO(developer): Set table_id to the ID of the table to create.
+    # table_id = "your-project.your_dataset.your_table_name
+
+    # Set the encryption key to use for the destination.
+    # TODO: Replace this key with a key you have created in KMS.
+    # kms_key_name = "projects/{}/locations/{}/keyRings/{}/cryptoKeys/{}".format(
+    #     "cloud-samples-tests", "us", "test", "test"
+    # )
+    job_config = bigquery.LoadJobConfig(
+        autodetect=True, source_format=bigquery.SourceFormat.NEWLINE_DELIMITED_JSON
+    )
+    uri = "gs://cloud-samples-data/bigquery/us-states/us-states.json"
+    load_job = client.load_table_from_uri(
+        uri, table_id, job_config=job_config
+    )  # Make an API request.
+    load_job.result()  # Waits for the job to complete.
+    destination_table = client.get_table(table_id)
+    print("Loaded {} rows.".format(destination_table.num_rows))
+    # [END bigquery_load_table_gcs_json_autodetect]

testbed/googleapis__python-bigquery/samples/load_table_uri_avro.py

@@ -0,0 +1,37 @@
+# Copyright 2020 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+def load_table_uri_avro(table_id: str) -> None:
+    # [START bigquery_load_table_gcs_avro]
+    from google.cloud import bigquery
+
+    # Construct a BigQuery client object.
+    client = bigquery.Client()
+
+    # TODO(developer): Set table_id to the ID of the table to create.
+    # table_id = "your-project.your_dataset.your_table_name
+
+    job_config = bigquery.LoadJobConfig(source_format=bigquery.SourceFormat.AVRO)
+    uri = "gs://cloud-samples-data/bigquery/us-states/us-states.avro"
+
+    load_job = client.load_table_from_uri(
+        uri, table_id, job_config=job_config
+    )  # Make an API request.
+
+    load_job.result()  # Waits for the job to complete.
+
+    destination_table = client.get_table(table_id)
+    print("Loaded {} rows.".format(destination_table.num_rows))
+    # [END bigquery_load_table_gcs_avro]