refactor(bigquery): update manage view and result as dataframe

bigquery/docs/snippets.py

@@ -456,131 +456,6 @@ def test_update_table_cmek(client, to_delete):
     # [END bigquery_update_table_cmek]
 
 
-@pytest.mark.skip(
-    reason=(
-        "update_table() is flaky "
-        "https://github.com/GoogleCloudPlatform/google-cloud-python/issues/5589"
-    )
-)
-def test_manage_views(client, to_delete):
-    project = client.project
-    source_dataset_id = "source_dataset_{}".format(_millis())
-    source_dataset_ref = client.dataset(source_dataset_id)
-    source_dataset = bigquery.Dataset(source_dataset_ref)
-    source_dataset = client.create_dataset(source_dataset)
-    to_delete.append(source_dataset)
-
-    job_config = bigquery.LoadJobConfig()
-    job_config.schema = [
-        bigquery.SchemaField("name", "STRING"),
-        bigquery.SchemaField("post_abbr", "STRING"),
-    ]
-    job_config.skip_leading_rows = 1
-    uri = "gs://cloud-samples-data/bigquery/us-states/us-states.csv"
-    source_table_id = "us_states"
-    load_job = client.load_table_from_uri(
-        uri, source_dataset.table(source_table_id), job_config=job_config
-    )
-    load_job.result()
-
-    shared_dataset_id = "shared_dataset_{}".format(_millis())
-    shared_dataset_ref = client.dataset(shared_dataset_id)
-    shared_dataset = bigquery.Dataset(shared_dataset_ref)
-    shared_dataset = client.create_dataset(shared_dataset)
-    to_delete.append(shared_dataset)
-
-    # [START bigquery_create_view]
-    # from google.cloud import bigquery
-    # client = bigquery.Client()
-    # project = 'my-project'
-    # source_dataset_id = 'my_source_dataset'
-    # source_table_id = 'us_states'
-    # shared_dataset_ref = client.dataset('my_shared_dataset')
-
-    # This example shows how to create a shared view of a source table of
-    # US States. The source table contains all 50 states, while the view will
-    # contain only states with names starting with 'W'.
-    view_ref = shared_dataset_ref.table("my_shared_view")
-    view = bigquery.Table(view_ref)
-    sql_template = 'SELECT name, post_abbr FROM `{}.{}.{}` WHERE name LIKE "W%"'
-    view.view_query = sql_template.format(project, source_dataset_id, source_table_id)
-    view = client.create_table(view)  # API request
-
-    print("Successfully created view at {}".format(view.full_table_id))
-    # [END bigquery_create_view]
-
-    # [START bigquery_update_view_query]
-    # from google.cloud import bigquery
-    # client = bigquery.Client()
-    # project = 'my-project'
-    # source_dataset_id = 'my_source_dataset'
-    # source_table_id = 'us_states'
-    # shared_dataset_ref = client.dataset('my_shared_dataset')
-
-    # This example shows how to update a shared view of a source table of
-    # US States. The view's query will be updated to contain only states with
-    # names starting with 'M'.
-    view_ref = shared_dataset_ref.table("my_shared_view")
-    view = bigquery.Table(view_ref)
-    sql_template = 'SELECT name, post_abbr FROM `{}.{}.{}` WHERE name LIKE "M%"'
-    view.view_query = sql_template.format(project, source_dataset_id, source_table_id)
-    view = client.update_table(view, ["view_query"])  # API request
-    # [END bigquery_update_view_query]
-
-    # [START bigquery_get_view]
-    # from google.cloud import bigquery
-    # client = bigquery.Client()
-    # shared_dataset_id = 'my_shared_dataset'
-
-    view_ref = client.dataset(shared_dataset_id).table("my_shared_view")
-    view = client.get_table(view_ref)  # API Request
-
-    # Display view properties
-    print("View at {}".format(view.full_table_id))
-    print("View Query:\n{}".format(view.view_query))
-    # [END bigquery_get_view]
-    assert view.view_query is not None
-
-    analyst_group_email = "[email protected]"
-    # [START bigquery_grant_view_access]
-    # from google.cloud import bigquery
-    # client = bigquery.Client()
-
-    # Assign access controls to the dataset containing the view
-    # shared_dataset_id = 'my_shared_dataset'
-    # analyst_group_email = '[email protected]'
-    shared_dataset = client.get_dataset(
-        client.dataset(shared_dataset_id)
-    )  # API request
-    access_entries = shared_dataset.access_entries
-    access_entries.append(
-        bigquery.AccessEntry("READER", "groupByEmail", analyst_group_email)
-    )
-    shared_dataset.access_entries = access_entries
-    shared_dataset = client.update_dataset(
-        shared_dataset, ["access_entries"]
-    )  # API request
-
-    # Authorize the view to access the source dataset
-    # project = 'my-project'
-    # source_dataset_id = 'my_source_dataset'
-    source_dataset = client.get_dataset(
-        client.dataset(source_dataset_id)
-    )  # API request
-    view_reference = {
-        "projectId": project,
-        "datasetId": shared_dataset_id,
-        "tableId": "my_shared_view",
-    }
-    access_entries = source_dataset.access_entries
-    access_entries.append(bigquery.AccessEntry(None, "view", view_reference))
-    source_dataset.access_entries = access_entries
-    source_dataset = client.update_dataset(
-        source_dataset, ["access_entries"]
-    )  # API request
-    # [END bigquery_grant_view_access]
-
-
 def test_load_table_from_file(client, to_delete):
     """Upload table data from a CSV file."""
     dataset_id = "load_table_from_file_dataset_{}".format(_millis())
@@ -1359,100 +1234,5 @@ def test_query_external_gcs_permanent_table(client, to_delete):
     assert len(w_states) == 4
 
 
-def test_ddl_create_view(client, to_delete, capsys):
-    """Create a view via a DDL query."""
-    project = client.project
-    dataset_id = "ddl_view_{}".format(_millis())
-    table_id = "new_view"
-    dataset = bigquery.Dataset(client.dataset(dataset_id))
-    client.create_dataset(dataset)
-    to_delete.append(dataset)
-
-    # [START bigquery_ddl_create_view]
-    # from google.cloud import bigquery
-    # project = 'my-project'
-    # dataset_id = 'my_dataset'
-    # table_id = 'new_view'
-    # client = bigquery.Client(project=project)
-
-    sql = """
-    CREATE VIEW `{}.{}.{}`
-    OPTIONS(
-        expiration_timestamp=TIMESTAMP_ADD(
-            CURRENT_TIMESTAMP(), INTERVAL 48 HOUR),
-        friendly_name="new_view",
-        description="a view that expires in 2 days",
-        labels=[("org_unit", "development")]
-    )
-    AS SELECT name, state, year, number
-        FROM `bigquery-public-data.usa_names.usa_1910_current`
-        WHERE state LIKE 'W%'
-    """.format(
-        project, dataset_id, table_id
-    )
-
-    job = client.query(sql)  # API request.
-    job.result()  # Waits for the query to finish.
-
-    print(
-        'Created new view "{}.{}.{}".'.format(
-            job.destination.project,
-            job.destination.dataset_id,
-            job.destination.table_id,
-        )
-    )
-    # [END bigquery_ddl_create_view]
-
-    out, _ = capsys.readouterr()
-    assert 'Created new view "{}.{}.{}".'.format(project, dataset_id, table_id) in out
-
-    # Test that listing query result rows succeeds so that generic query
-    # processing tools work with DDL statements.
-    rows = list(job)
-    assert len(rows) == 0
-
-    if pandas is not None:
-        df = job.to_dataframe()
-        assert len(df) == 0
-
-
-@pytest.mark.skipif(pandas is None, reason="Requires `pandas`")
-def test_query_results_as_dataframe(client):
-    # [START bigquery_query_results_dataframe]
-    # from google.cloud import bigquery
-    # client = bigquery.Client()
-
-    sql = """
-        SELECT name, SUM(number) as count
-        FROM `bigquery-public-data.usa_names.usa_1910_current`
-        GROUP BY name
-        ORDER BY count DESC
-        LIMIT 10
-    """
-
-    df = client.query(sql).to_dataframe()
-    # [END bigquery_query_results_dataframe]
-    assert isinstance(df, pandas.DataFrame)
-    assert len(list(df)) == 2  # verify the number of columns
-    assert len(df) == 10  # verify the number of rows
-
-
-@pytest.mark.skipif(pandas is None, reason="Requires `pandas`")
-def test_list_rows_as_dataframe(client):
-    # [START bigquery_list_rows_dataframe]
-    # from google.cloud import bigquery
-    # client = bigquery.Client()
-
-    dataset_ref = client.dataset("samples", project="bigquery-public-data")
-    table_ref = dataset_ref.table("shakespeare")
-    table = client.get_table(table_ref)
-
-    df = client.list_rows(table).to_dataframe()
-    # [END bigquery_list_rows_dataframe]
-    assert isinstance(df, pandas.DataFrame)
-    assert len(list(df)) == len(table.schema)  # verify the number of columns
-    assert len(df) == table.num_rows  # verify the number of rows
-
-
 if __name__ == "__main__":
     pytest.main()

bigquery/docs/usage/pandas.rst

@@ -23,15 +23,15 @@ Alternatively, you can install the BigQuery python client library with
 
 To retrieve query results as a :class:`pandas.DataFrame`:
 
-.. literalinclude:: ../snippets.py
+.. literalinclude:: ../samples/query_results_as_dataframe.py
    :language: python
    :dedent: 4
    :start-after: [START bigquery_query_results_dataframe]
    :end-before: [END bigquery_query_results_dataframe]
 
 To retrieve table rows as a :class:`pandas.DataFrame`:
 
-.. literalinclude:: ../snippets.py
+.. literalinclude:: ../samples/list_rows_as_dataframe.py
    :language: python
    :dedent: 4
    :start-after: [START bigquery_list_rows_dataframe]

bigquery/docs/usage/tables.rst

@@ -198,3 +198,46 @@ Restore a deleted table from a snapshot by using the
    :dedent: 4
    :start-after: [START bigquery_undelete_table]
    :end-before: [END bigquery_undelete_table]
+
+Share a view of Table
+^^^^^^^^^^^^^^^^^^^^^^
+
+Create and share a view of source table:
+
+.. literalinclude:: ../samples/create_view.py
+   :language: python
+   :dedent: 4
+   :start-after: [START bigquery_create_view]
+   :end-before: [END bigquery_create_view]
+
+Create a view via DDL query:
+
+.. literalinclude:: ../samples/create_view_dll.py
+   :language: python
+   :dedent: 4
+   :start-after: [START bigquery_ddl_create_view]
+   :end-before: [END bigquery_ddl_create_view]
+
+Update a shared view of a source table:
+
+.. literalinclude:: ../samples/update_view.py
+   :language: python
+   :dedent: 4
+   :start-after: [START bigquery_update_view_query]
+   :end-before: [END bigquery_update_view_query]
+
+Authorize the view to access the source dataset:
+
+.. literalinclude:: ../samples/grant_view_access.py
+   :language: python
+   :dedent: 4
+   :start-after: [START bigquery_grant_view_access]
+   :end-before: [END bigquery_grant_view_access]
+
+Get a view of table:
+
+.. literalinclude:: ../samples/get_view.py
+   :language: python
+   :dedent: 4
+   :start-after: [START bigquery_get_view]
+   :end-before: [END bigquery_get_view]

bigquery/noxfile.py

@@ -175,7 +175,7 @@ def lint_setup_py(session):
     session.run("python", "setup.py", "check", "--restructuredtext", "--strict")
 
 
-@nox.session(python="3.6")
+@nox.session(python="3.7")
 def blacken(session):
     """Run black.
     Format code to uniform standard.

bigquery/samples/create_view.py

@@ -0,0 +1,54 @@
+# 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 create_view(load_table_id, table_id):
+
+    # [START bigquery_create_view]
+    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 load the data.
+    # load_table_id = "your-project.your_dataset.your_table_name"
+
+    # 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(
+        schema=[
+            bigquery.SchemaField("name", "STRING"),
+            bigquery.SchemaField("post_abbr", "STRING"),
+        ],
+        skip_leading_rows=1,
+    )
+    uri = "gs://cloud-samples-data/bigquery/us-states/us-states.csv"
+
+    load_job = client.load_table_from_uri(uri, load_table_id, job_config=job_config)
+    load_job.result()
+    table = client.get_table(load_table_id)
+    view = bigquery.Table(table_id)
+    sql_template = 'SELECT name, post_abbr FROM `{}.{}.{}` WHERE name LIKE "W%"'
+    view.view_query = sql_template.format(
+        view.project, table.dataset_id, table.table_id
+    )
+    view = client.create_table(view)  # Make an API request.
+
+    print(
+        "Successfully created view at {}.{}.{}".format(
+            view.project, view.dataset_id, view.table_id
+        )
+    )
+    # [END bigquery_create_view]