diff --git a/owl-bot-staging/pandas-gbq/pandas-gbq/pandas-gbq.txt b/owl-bot-staging/pandas-gbq/pandas-gbq/pandas-gbq.txt
new file mode 100644
index 000000000000..e69de29bb2d1
diff --git a/packages/pandas-gbq/.coveragerc b/packages/pandas-gbq/.coveragerc
new file mode 100644
index 000000000000..b5577cddf390
--- /dev/null
+++ b/packages/pandas-gbq/.coveragerc
@@ -0,0 +1,39 @@
+# -*- coding: utf-8 -*-
+#
+# 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.
+
+# Generated by synthtool. DO NOT EDIT!
+[run]
+branch = True
+omit =
+  google/__init__.py
+  google/cloud/__init__.py
+
+[report]
+fail_under = 96
+show_missing = True
+exclude_lines =
+    # Re-enable the standard pragma
+    pragma: NO COVER
+    # Ignore debug-only repr
+    def __repr__
+    # Ignore abstract methods
+    raise NotImplementedError
+omit =
+  */gapic/*.py
+  */proto/*.py
+  */core/*.py
+  */site-packages/*.py
+  google/cloud/__init__.py
diff --git a/packages/pandas-gbq/.flake8 b/packages/pandas-gbq/.flake8
new file mode 100644
index 000000000000..32986c79287a
--- /dev/null
+++ b/packages/pandas-gbq/.flake8
@@ -0,0 +1,33 @@
+# -*- coding: utf-8 -*-
+#
+# 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.
+
+# Generated by synthtool. DO NOT EDIT!
+[flake8]
+ignore = E203, E231, E266, E501, W503
+exclude =
+  # Exclude generated code.
+  **/proto/**
+  **/gapic/**
+  **/services/**
+  **/types/**
+  *_pb2.py
+
+  # Standard linting exemptions.
+  **/.nox/**
+  __pycache__,
+  .git,
+  *.pyc,
+  conf.py
diff --git a/packages/pandas-gbq/.gitattributes b/packages/pandas-gbq/.gitattributes
new file mode 100644
index 000000000000..9afa48862e72
--- /dev/null
+++ b/packages/pandas-gbq/.gitattributes
@@ -0,0 +1 @@
+pandas_gbq/_version.py export-subst
diff --git a/packages/pandas-gbq/.gitignore b/packages/pandas-gbq/.gitignore
new file mode 100644
index 000000000000..d083ea1ddc3e
--- /dev/null
+++ b/packages/pandas-gbq/.gitignore
@@ -0,0 +1,64 @@
+*.py[cod]
+*.sw[op]
+
+# C extensions
+*.so
+
+# Packages
+*.egg
+*.egg-info
+dist
+build
+eggs
+.eggs
+parts
+bin
+var
+sdist
+develop-eggs
+.installed.cfg
+lib
+lib64
+__pycache__
+
+# Installer logs
+pip-log.txt
+
+# Unit test / coverage reports
+.coverage
+.nox
+.cache
+.pytest_cache
+
+
+# Mac
+.DS_Store
+
+# JetBrains
+.idea
+
+# VS Code
+.vscode
+
+# emacs
+*~
+
+# Built documentation
+docs/_build
+bigquery/docs/generated
+docs.metadata
+
+# Virtual environment
+env/
+venv/
+
+# Test logs
+coverage.xml
+*sponge_log.xml
+
+# System test environment variables.
+system_tests/local_test_setup
+
+# Make sure a generated file isn't accidentally committed.
+pylintrc
+pylintrc.test
diff --git a/packages/pandas-gbq/.librarian/state.yaml b/packages/pandas-gbq/.librarian/state.yaml
new file mode 100644
index 000000000000..931526b27f11
--- /dev/null
+++ b/packages/pandas-gbq/.librarian/state.yaml
@@ -0,0 +1,11 @@
+image: us-central1-docker.pkg.dev/cloud-sdk-librarian-prod/images-prod/python-librarian-generator@sha256:c8612d3fffb3f6a32353b2d1abd16b61e87811866f7ec9d65b59b02eb452a620
+libraries:
+  - id: pandas-gbq
+    version: 0.31.0
+    last_generated_commit: ""
+    apis: []
+    source_roots:
+      - .
+    preserve_regex: []
+    remove_regex: []
+    tag_format: v{version}
diff --git a/packages/pandas-gbq/.pre-commit-config.yaml b/packages/pandas-gbq/.pre-commit-config.yaml
new file mode 100644
index 000000000000..1d74695f70b6
--- /dev/null
+++ b/packages/pandas-gbq/.pre-commit-config.yaml
@@ -0,0 +1,31 @@
+# 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
+#
+# 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.
+#
+# See https://pre-commit.com for more information
+# See https://pre-commit.com/hooks.html for more hooks
+repos:
+-   repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v4.0.1
+    hooks:
+    -   id: trailing-whitespace
+    -   id: end-of-file-fixer
+    -   id: check-yaml
+-   repo: https://github.com/psf/black
+    rev: 23.7.0
+    hooks:
+    - id: black
+-   repo: https://github.com/pycqa/flake8
+    rev: 6.1.0
+    hooks:
+    - id: flake8
diff --git a/packages/pandas-gbq/.readthedocs.yml b/packages/pandas-gbq/.readthedocs.yml
new file mode 100644
index 000000000000..86e0f0fb0367
--- /dev/null
+++ b/packages/pandas-gbq/.readthedocs.yml
@@ -0,0 +1,24 @@
+# Copyright (c) 2017 pandas-gbq Authors All rights reserved.
+# Use of this source code is governed by a BSD-style
+# license that can be found in the LICENSE file.
+
+# .readthedocs.yaml
+# Read the Docs configuration file
+# See https://docs.readthedocs.io/en/stable/config-file/v2.html for details
+
+version: 2
+
+build:
+  os: ubuntu-22.04
+  tools:
+    python: "3.11"
+
+python:
+  install:
+  - requirements: docs/requirements-docs.txt
+
+# Explicit configuration path is required by ReadtheDocs starting Jan 20, 2025.
+# See: https://about.readthedocs.com/blog/2024/12/deprecate-config-files-without-sphinx-or-mkdocs-config/
+version: 2
+sphinx:
+  configuration: docs/conf.py
diff --git a/packages/pandas-gbq/.repo-metadata.json b/packages/pandas-gbq/.repo-metadata.json
new file mode 100644
index 000000000000..b016c47d5e3f
--- /dev/null
+++ b/packages/pandas-gbq/.repo-metadata.json
@@ -0,0 +1,15 @@
+{
+    "name": "pandas-gbq",
+    "name_pretty": "Google BigQuery connector for pandas",
+    "product_documentation": "https://cloud.google.com/bigquery",
+    "client_documentation": "https://googleapis.dev/python/pandas-gbq/latest/",
+    "issue_tracker": "https://github.com/googleapis/python-bigquery-pandas/issues",
+    "release_level": "preview",
+    "language": "python",
+    "library_type": "INTEGRATION",
+    "repo": "googleapis/python-bigquery-pandas",
+    "distribution_name": "pandas-gbq",
+    "api_id": "bigquery.googleapis.com",
+    "default_version": "",
+    "codeowner_team": "@googleapis/api-bigquery @googleapis/api-bigquery-dataframe"
+}
diff --git a/packages/pandas-gbq/AUTHORS.md b/packages/pandas-gbq/AUTHORS.md
new file mode 100644
index 000000000000..152c93a42360
--- /dev/null
+++ b/packages/pandas-gbq/AUTHORS.md
@@ -0,0 +1,56 @@
+About the Copyright Holders
+===========================
+
+*   Copyright (c) 2008-2011 AQR Capital Management, LLC
+
+    AQR Capital Management began pandas development in 2008. Development was
+    led by Wes McKinney. AQR released the source under this license in 2009.
+*   Copyright (c) 2011-2012, Lambda Foundry, Inc.
+
+    Wes is now an employee of Lambda Foundry, and remains the pandas project
+    lead.
+*   Copyright (c) 2011-2012, PyData Development Team
+
+    The PyData Development Team is the collection of developers of the PyData
+    project. This includes all of the PyData sub-projects, including pandas. The
+    core team that coordinates development on GitHub can be found here:
+    http://github.com/pydata.
+
+Full credits for pandas contributors can be found in the documentation.
+
+Our Copyright Policy
+====================
+
+PyData uses a shared copyright model. Each contributor maintains copyright
+over their contributions to PyData. However, it is important to note that
+these contributions are typically only changes to the repositories. Thus,
+the PyData source code, in its entirety, is not the copyright of any single
+person or institution. Instead, it is the collective copyright of the
+entire PyData Development Team. If individual contributors want to maintain
+a record of what changes/contributions they have specific copyright on,
+they should indicate their copyright in the commit message of the change
+when they commit the change to one of the PyData repositories.
+
+With this in mind, the following banner should be used in any source code
+file to indicate the copyright and license terms:
+
+```
+#-----------------------------------------------------------------------------
+# Copyright (c) 2012, PyData Development Team
+# All rights reserved.
+#
+# Distributed under the terms of the BSD Simplified License.
+#
+# The full license is in the LICENSE file, distributed with this software.
+#-----------------------------------------------------------------------------
+```
+
+Other licenses can be found in the LICENSES directory.
+
+License
+=======
+
+pandas is distributed under a 3-clause ("Simplified" or "New") BSD
+license. Parts of NumPy, SciPy, numpydoc, bottleneck, which all have
+BSD-compatible licenses, are included. Their licenses follow the pandas
+license.
diff --git a/packages/pandas-gbq/CHANGELOG.md b/packages/pandas-gbq/CHANGELOG.md
new file mode 100644
index 000000000000..ee12fc18769b
--- /dev/null
+++ b/packages/pandas-gbq/CHANGELOG.md
@@ -0,0 +1,844 @@
+# Changelog
+
+[PyPI History][1]
+
+[1]: https://pypi.org/project/pandas-gbq/#history
+
+## [0.31.0](https://github.com/googleapis/python-bigquery-pandas/compare/v0.30.0...v0.31.0) (2025-11-17)
+
+
+### Features
+
+* add pandas_gbq.sample (#983) ([ac771c12f58b7378a8550515c9c656da7fa980a8](https://github.com/googleapis/python-bigquery-pandas/commit/ac771c12f58b7378a8550515c9c656da7fa980a8))
+
+## [0.30.0](https://github.com/googleapis/python-bigquery-pandas/compare/v0.29.2...v0.30.0) (2025-10-31)
+
+
+### Features
+
+* Add partitioning and clustering parameters to the `to_gbq` function ([#949](https://github.com/googleapis/python-bigquery-pandas/issues/949)) ([e7213c7](https://github.com/googleapis/python-bigquery-pandas/commit/e7213c7760582a58b03d75886e5754fd3083e622))
+* Allow loading a DataFrame even if the provided BigQuery schema includes columns not in the DataFrame ([#953](https://github.com/googleapis/python-bigquery-pandas/issues/953)) ([a529505](https://github.com/googleapis/python-bigquery-pandas/commit/a5295056f3a22d60ed0d375cc4d23469a0ccea95))
+
+## [0.29.2](https://github.com/googleapis/python-bigquery-pandas/compare/v0.29.1...v0.29.2) (2025-07-10)
+
+
+### Features
+
+* Add Python 3.13 support ([#930](https://github.com/googleapis/python-bigquery-pandas/issues/930)) ([76e6d11](https://github.com/googleapis/python-bigquery-pandas/commit/76e6d11aaf674bc4bb4de223845cc31fe3cf5765))
+
+
+### Dependencies
+
+* Remove support for Python 3.8 ([#932](https://github.com/googleapis/python-bigquery-pandas/issues/932)) ([ba35a9c](https://github.com/googleapis/python-bigquery-pandas/commit/ba35a9c3fe1acef13a629dacbc92d00f4291aa63))
+
+
+### Miscellaneous Chores
+
+* Release 0.29.2 ([#937](https://github.com/googleapis/python-bigquery-pandas/issues/937)) ([e595c2b](https://github.com/googleapis/python-bigquery-pandas/commit/e595c2b1b237252e48004fcb77c0f33ddbd42b5a))
+
+## [0.29.1](https://github.com/googleapis/python-bigquery-pandas/compare/v0.29.0...v0.29.1) (2025-06-03)
+
+
+### Bug Fixes
+
+* Remove pandas-gbq client ID for authentication ([#927](https://github.com/googleapis/python-bigquery-pandas/issues/927)) ([8bb7401](https://github.com/googleapis/python-bigquery-pandas/commit/8bb74015ca47ccca37cb5077bae265a257bec8cc))
+
+## [0.29.0](https://github.com/googleapis/python-bigquery-pandas/compare/v0.28.1...v0.29.0) (2025-05-14)
+
+
+### Features
+
+* Instrument vscode, jupyter and 3p plugin usage ([#925](https://github.com/googleapis/python-bigquery-pandas/issues/925)) ([7d354f1](https://github.com/googleapis/python-bigquery-pandas/commit/7d354f1ca90eb2647c81d8d8422d0146d56f802a))
+
+## [0.28.1](https://github.com/googleapis/python-bigquery-pandas/compare/v0.28.0...v0.28.1) (2025-04-28)
+
+
+### Bug Fixes
+
+* Remove setup.cfg configuration for creating universal wheels ([#898](https://github.com/googleapis/python-bigquery-pandas/issues/898)) ([b3a9af2](https://github.com/googleapis/python-bigquery-pandas/commit/b3a9af27960c6e2736835d6a94e116f550f94114))
+* Remove unnecessary global variable definition ([#907](https://github.com/googleapis/python-bigquery-pandas/issues/907)) ([d4d85ce](https://github.com/googleapis/python-bigquery-pandas/commit/d4d85ce133fcdb98b53684f8dfca9d25c032b09e))
+* Resolve issue where pre-release versions of dependencies are installed ([#890](https://github.com/googleapis/python-bigquery-pandas/issues/890)) ([3574ca1](https://github.com/googleapis/python-bigquery-pandas/commit/3574ca181fe91ee65114835fd7db8bdd75fe135a))
+
+## [0.28.0](https://github.com/googleapis/python-bigquery-pandas/compare/v0.27.0...v0.28.0) (2025-02-24)
+
+
+### Features
+
+* Add bigquery_client as a parameter for read_gbq and to_gbq ([#878](https://github.com/googleapis/python-bigquery-pandas/issues/878)) ([d42a562](https://github.com/googleapis/python-bigquery-pandas/commit/d42a56200fe2f356240c7956da4c201e872be4d5))
+
+## [0.27.0](https://github.com/googleapis/python-bigquery-pandas/compare/v0.26.1...v0.27.0) (2025-02-05)
+
+
+### Features
+
+* `to_gbq` can write non-string values to existing STRING columns in BigQuery ([#876](https://github.com/googleapis/python-bigquery-pandas/issues/876)) ([ee30a1e](https://github.com/googleapis/python-bigquery-pandas/commit/ee30a1e04a6731275846c04acad6e9646eb4f908))
+
+## [0.26.1](https://github.com/googleapis/python-bigquery-pandas/compare/v0.26.0...v0.26.1) (2025-01-06)
+
+
+### Bug Fixes
+
+* Ensure BIGNUMERIC type is used if scale > 9 in Decimal values ([#844](https://github.com/googleapis/python-bigquery-pandas/issues/844)) ([d2f32df](https://github.com/googleapis/python-bigquery-pandas/commit/d2f32df4670f4c18464c6772896bf1583c36e338))
+
+## [0.26.0](https://github.com/googleapis/python-bigquery-pandas/compare/v0.25.0...v0.26.0) (2024-12-19)
+
+
+### Features
+
+* `to_gbq` fails with `TypeError` if passing in a bigframes DataFrame object ([#833](https://github.com/googleapis/python-bigquery-pandas/issues/833)) ([5004d08](https://github.com/googleapis/python-bigquery-pandas/commit/5004d08c6af93471686ccb319c69cd38c7893042))
+
+
+### Bug Fixes
+
+* `to_gbq` uses `default_type` for ambiguous array types and struct field types ([#838](https://github.com/googleapis/python-bigquery-pandas/issues/838)) ([cf1aadd](https://github.com/googleapis/python-bigquery-pandas/commit/cf1aadd48165617768fecff91e68941255148dbd))
+
+## [0.25.0](https://github.com/googleapis/python-bigquery-pandas/compare/v0.24.0...v0.25.0) (2024-12-11)
+
+
+### ⚠ BREAKING CHANGES
+
+* to_gbq uploads ArrowDtype(pa.timestamp(...) without timezone as DATETIME type ([#832](https://github.com/googleapis/python-bigquery-pandas/issues/832))
+
+### Bug Fixes
+
+* To_gbq uploads ArrowDtype(pa.timestamp(...) without timezone as DATETIME type ([#832](https://github.com/googleapis/python-bigquery-pandas/issues/832)) ([2104b71](https://github.com/googleapis/python-bigquery-pandas/commit/2104b71a8ac1513a49b6e8bb73636d6b2f363d0e))
+
+## [0.24.0](https://github.com/googleapis/python-bigquery-pandas/compare/v0.23.2...v0.24.0) (2024-10-14)
+
+
+### ⚠ BREAKING CHANGES
+
+* `to_gbq` loads naive (no timezone) columns to BigQuery DATETIME instead of TIMESTAMP ([#814](https://github.com/googleapis/python-bigquery-pandas/issues/814))
+* `to_gbq` loads object column containing bool values to BOOLEAN instead of STRING ([#814](https://github.com/googleapis/python-bigquery-pandas/issues/814))
+* `to_gbq` loads object column containing dictionary values to STRUCT instead of STRING ([#814](https://github.com/googleapis/python-bigquery-pandas/issues/814))
+* `to_gbq` loads `unit8` columns to BigQuery INT64 instead of STRING ([#814](https://github.com/googleapis/python-bigquery-pandas/issues/814))
+
+### Features
+
+* Adds the capability to include custom user agent string ([#819](https://github.com/googleapis/python-bigquery-pandas/issues/819)) ([d43457b](https://github.com/googleapis/python-bigquery-pandas/commit/d43457b3838bdc135337cae47c56af397bb1d6d1))
+
+
+### Bug Fixes
+
+* `to_gbq` loads `unit8` columns to BigQuery INT64 instead of STRING ([#814](https://github.com/googleapis/python-bigquery-pandas/issues/814)) ([107bb40](https://github.com/googleapis/python-bigquery-pandas/commit/107bb40218b531be1a4f646b8fb0cea5bdfd8aee))
+* `to_gbq` loads naive (no timezone) columns to BigQuery DATETIME instead of TIMESTAMP ([#814](https://github.com/googleapis/python-bigquery-pandas/issues/814)) ([107bb40](https://github.com/googleapis/python-bigquery-pandas/commit/107bb40218b531be1a4f646b8fb0cea5bdfd8aee))
+* `to_gbq` loads object column containing bool values to BOOLEAN instead of STRING ([#814](https://github.com/googleapis/python-bigquery-pandas/issues/814)) ([107bb40](https://github.com/googleapis/python-bigquery-pandas/commit/107bb40218b531be1a4f646b8fb0cea5bdfd8aee))
+* `to_gbq` loads object column containing dictionary values to STRUCT instead of STRING ([#814](https://github.com/googleapis/python-bigquery-pandas/issues/814)) ([107bb40](https://github.com/googleapis/python-bigquery-pandas/commit/107bb40218b531be1a4f646b8fb0cea5bdfd8aee))
+
+
+### Dependencies
+
+* Min pyarrow is now 4.0.0 to support compliant nested types ([#814](https://github.com/googleapis/python-bigquery-pandas/issues/814)) ([107bb40](https://github.com/googleapis/python-bigquery-pandas/commit/107bb40218b531be1a4f646b8fb0cea5bdfd8aee))
+
+## [0.23.2](https://github.com/googleapis/python-bigquery-pandas/compare/v0.23.1...v0.23.2) (2024-09-20)
+
+
+### Bug Fixes
+
+* **deps:** Require google-cloud-bigquery >= 3.4.2 ([5e14496](https://github.com/googleapis/python-bigquery-pandas/commit/5e144968893c476ffc9866461d128298e6b49d62))
+* **deps:** Require numpy >=1.18.1 ([5e14496](https://github.com/googleapis/python-bigquery-pandas/commit/5e144968893c476ffc9866461d128298e6b49d62))
+* **deps:** Require packaging >= 22.0 ([5e14496](https://github.com/googleapis/python-bigquery-pandas/commit/5e144968893c476ffc9866461d128298e6b49d62))
+
+
+### Documentation
+
+* Fix typo in 'vebosity' ([#803](https://github.com/googleapis/python-bigquery-pandas/issues/803)) ([a7641c9](https://github.com/googleapis/python-bigquery-pandas/commit/a7641c9b13be7f8649f43d985dac29cc7e05be0b))
+
+## [0.23.1](https://github.com/googleapis/python-bigquery-pandas/compare/v0.23.0...v0.23.1) (2024-06-07)
+
+
+### Bug Fixes
+
+* Handle None when converting numerics to parquet ([#768](https://github.com/googleapis/python-bigquery-pandas/issues/768)) ([53a4683](https://github.com/googleapis/python-bigquery-pandas/commit/53a46833a320963d5c15427f6eb631e0199fb332))
+
+
+### Documentation
+
+* Use a short-link to BigQuery DataFrames ([#773](https://github.com/googleapis/python-bigquery-pandas/issues/773)) ([7cd4287](https://github.com/googleapis/python-bigquery-pandas/commit/7cd4287ae70861e4949487db578ab1916d853029))
+
+## [0.23.0](https://github.com/googleapis/python-bigquery-pandas/compare/v0.22.0...v0.23.0) (2024-05-20)
+
+
+### Features
+
+* `read_gbq` suggests using BigQuery DataFrames with large results ([#769](https://github.com/googleapis/python-bigquery-pandas/issues/769)) ([f937edf](https://github.com/googleapis/python-bigquery-pandas/commit/f937edf5db910257a367b4cc20d865a38b440f75))
+
+## [0.22.0](https://github.com/googleapis/python-bigquery-pandas/compare/v0.21.0...v0.22.0) (2024-03-05)
+
+
+### Features
+
+* Move bqstorage to extras and add debug capability ([#735](https://github.com/googleapis/python-bigquery-pandas/issues/735)) ([366cb55](https://github.com/googleapis/python-bigquery-pandas/commit/366cb55a5f2dde4f92994de9ba6c59eb3e1d7c9f))
+
+
+### Bug Fixes
+
+* Remove python 3.7 due to end of life (EOL) ([#737](https://github.com/googleapis/python-bigquery-pandas/issues/737)) ([d0810e8](https://github.com/googleapis/python-bigquery-pandas/commit/d0810e82322c5cc81b33894b7e7f50c140f542ed))
+
+## [0.21.0](https://github.com/googleapis/python-bigquery-pandas/compare/v0.20.0...v0.21.0) (2024-01-25)
+
+
+### Features
+
+* Use faster query_and_wait method from google-cloud-bigquery when available ([#722](https://github.com/googleapis/python-bigquery-pandas/issues/722)) ([ac3ce3f](https://github.com/googleapis/python-bigquery-pandas/commit/ac3ce3fcd1637fe741af0a10d765ba3092d0e668))
+
+
+### Bug Fixes
+
+* Update runtime check for min google-cloud-bigquery to 3.3.5 ([#721](https://github.com/googleapis/python-bigquery-pandas/issues/721)) ([b5f4869](https://github.com/googleapis/python-bigquery-pandas/commit/b5f48690334edae5f54373a3a8864e3c3496ff29))
+
+## [0.20.0](https://github.com/googleapis/python-bigquery-pandas/compare/v0.19.2...v0.20.0) (2023-12-10)
+
+
+### Features
+
+* Add 'columns' as an alias for 'col_order' ([#701](https://github.com/googleapis/python-bigquery-pandas/issues/701)) ([e52e8f8](https://github.com/googleapis/python-bigquery-pandas/commit/e52e8f85e3f115ee1c9f3dc6733217b04d264f26))
+* Add support for Python 3.12 ([#702](https://github.com/googleapis/python-bigquery-pandas/issues/702)) ([edb93cc](https://github.com/googleapis/python-bigquery-pandas/commit/edb93cc1aee5e7ea931a1d620617be28b4c9a702))
+* Migrating off of circle/ci ([#638](https://github.com/googleapis/python-bigquery-pandas/issues/638)) ([08fe090](https://github.com/googleapis/python-bigquery-pandas/commit/08fe0904375077e43afc03c5529b427cfcf9aa37))
+* Removed pkg_resources for native namespace support ([#707](https://github.com/googleapis/python-bigquery-pandas/issues/707)) ([eeb1959](https://github.com/googleapis/python-bigquery-pandas/commit/eeb19593a75d55e88a2c51ae8eb258c0156d5ba6))
+
+
+### Bug Fixes
+
+* Edit units for time in tests ([#655](https://github.com/googleapis/python-bigquery-pandas/issues/655)) ([d4ebb0c](https://github.com/googleapis/python-bigquery-pandas/commit/d4ebb0cb530fde5a28663a4bec8f7f663e2f0c55))
+* Table schema change error ([#692](https://github.com/googleapis/python-bigquery-pandas/issues/692)) ([3dc8ebe](https://github.com/googleapis/python-bigquery-pandas/commit/3dc8ebed4809ad626dcf18124c38930c87750ac8))
+
+
+### Documentation
+
+* Migrate .readthedocs.yml to configuration file v2 ([#689](https://github.com/googleapis/python-bigquery-pandas/issues/689)) ([d921219](https://github.com/googleapis/python-bigquery-pandas/commit/d921219690b1b577346f5dc41c0e8d8e5ed2115c))
+
+## [0.19.2](https://github.com/googleapis/python-bigquery-pandas/compare/v0.19.1...v0.19.2) (2023-05-10)
+
+
+### Bug Fixes
+
+* Add exception context to GenericGBQExceptions ([#629](https://github.com/googleapis/python-bigquery-pandas/issues/629)) ([d17ae24](https://github.com/googleapis/python-bigquery-pandas/commit/d17ae244b8e249b1d5f3b6db667db5e84abaf85c))
+
+
+### Documentation
+
+* Correct the documented dtypes for `read_gbq` ([#598](https://github.com/googleapis/python-bigquery-pandas/issues/598)) ([b45651d](https://github.com/googleapis/python-bigquery-pandas/commit/b45651d5688034418cdf57244c39592ee5dea2b2))
+* Google Colab auth is used with pydata-google-auth 1.8.0+ ([#631](https://github.com/googleapis/python-bigquery-pandas/issues/631)) ([257aa62](https://github.com/googleapis/python-bigquery-pandas/commit/257aa6209345836e291ebd4f6feec0176c8b22e1))
+* Updates with a link to the canonical source of documentation ([#620](https://github.com/googleapis/python-bigquery-pandas/issues/620)) ([1dca732](https://github.com/googleapis/python-bigquery-pandas/commit/1dca732c71e022f1897d946e2ae914e9b51bc386))
+
+## [0.19.1](https://github.com/googleapis/python-bigquery-pandas/compare/v0.19.0...v0.19.1) (2023-01-25)
+
+
+### Documentation
+
+* Updates the user instructions re OAuth ([0c2b716](https://github.com/googleapis/python-bigquery-pandas/commit/0c2b716a55551f26050ed8d94ff912d406527ac5))
+
+## [0.19.0](https://github.com/googleapis/python-bigquery-pandas/compare/v0.18.1...v0.19.0) (2023-01-11)
+
+
+### Features
+
+* Adds ability to provide redirect uri ([#595](https://github.com/googleapis/python-bigquery-pandas/issues/595)) ([a06085e](https://github.com/googleapis/python-bigquery-pandas/commit/a06085eddddd18394f623d0b6f3a65d91f51e979))
+
+## [0.18.1](https://github.com/googleapis/python-bigquery-pandas/compare/v0.18.0...v0.18.1) (2022-11-28)
+
+
+### Dependencies
+
+* Remove upper bound for python and pyarrow ([#592](https://github.com/googleapis/python-bigquery-pandas/issues/592)) ([4d28684](https://github.com/googleapis/python-bigquery-pandas/commit/4d286840feaa8290f4d674dce1c269e7e09980d5))
+
+## [0.18.0](https://github.com/googleapis/python-bigquery-pandas/compare/v0.17.9...v0.18.0) (2022-11-19)
+
+
+### Features
+
+* Map "if_exists" value to LoadJobConfig.WriteDisposition ([#583](https://github.com/googleapis/python-bigquery-pandas/issues/583)) ([7389cd2](https://github.com/googleapis/python-bigquery-pandas/commit/7389cd2a363ebf403b66905ca845ca842a754922))
+
+## [0.17.9](https://github.com/googleapis/python-bigquery-pandas/compare/v0.17.8...v0.17.9) (2022-09-27)
+
+
+### Bug Fixes
+
+* Updates requirements.txt to fix failing tests due to missing req ([#575](https://github.com/googleapis/python-bigquery-pandas/issues/575)) ([1d797a3](https://github.com/googleapis/python-bigquery-pandas/commit/1d797a3337e716fa6f3de511e7c8875dfadde43b))
+
+## [0.17.8](https://github.com/googleapis/python-bigquery-pandas/compare/v0.17.7...v0.17.8) (2022-08-09)
+
+
+### Bug Fixes
+
+* **deps:** allow pyarrow < 10 ([#550](https://github.com/googleapis/python-bigquery-pandas/issues/550)) ([c21a414](https://github.com/googleapis/python-bigquery-pandas/commit/c21a41425d4d06b9df5fbdeb15e90f79de841612))
+
+## [0.17.7](https://github.com/googleapis/python-bigquery-pandas/compare/v0.17.6...v0.17.7) (2022-07-11)
+
+
+### Bug Fixes
+
+* allow `to_gbq` to run without `bigquery.tables.create` permission. ([#539](https://github.com/googleapis/python-bigquery-pandas/issues/539)) ([3988306](https://github.com/googleapis/python-bigquery-pandas/commit/3988306bd2cc7743d24e24d753730ba04462f018))
+
+## [0.17.6](https://github.com/googleapis/python-bigquery-pandas/compare/v0.17.5...v0.17.6) (2022-06-03)
+
+
+### Documentation
+
+* fix changelog header to consistent size ([#529](https://github.com/googleapis/python-bigquery-pandas/issues/529)) ([218e06a](https://github.com/googleapis/python-bigquery-pandas/commit/218e06af40e991f870649a8e958dfc1bc46f0ee8))
+
+## [0.17.5](https://github.com/googleapis/python-bigquery-pandas/compare/v0.17.4...v0.17.5) (2022-05-09)
+
+
+### Bug Fixes
+
+* **deps:** allow pyarrow v8 ([#525](https://github.com/googleapis/python-bigquery-pandas/issues/525)) ([a4ee0df](https://github.com/googleapis/python-bigquery-pandas/commit/a4ee0dffae0580a7509d5d6014edb46e05394717))
+
+## [0.17.4](https://github.com/googleapis/python-bigquery-pandas/compare/v0.17.3...v0.17.4) (2022-03-14)
+
+
+### Bug Fixes
+
+* avoid deprecated "out-of-band" authentication flow ([#500](https://github.com/googleapis/python-bigquery-pandas/issues/500)) ([4758e3a](https://github.com/googleapis/python-bigquery-pandas/commit/4758e3a9ccb82109aae65f76258b2910077e02dd))
+* correctly transform query job timeout configuration and exceptions ([#492](https://github.com/googleapis/python-bigquery-pandas/issues/492)) ([d8c3900](https://github.com/googleapis/python-bigquery-pandas/commit/d8c3900eda5aa2cb5b663b2be569d639f6a028a9))
+
+## [0.17.3](https://github.com/googleapis/python-bigquery-pandas/compare/v0.17.2...v0.17.3) (2022-03-05)
+
+
+### Bug Fixes
+
+* **deps:** require google-api-core>=1.31.5, >=2.3.2 ([#493](https://github.com/googleapis/python-bigquery-pandas/issues/493)) ([744a71c](https://github.com/googleapis/python-bigquery-pandas/commit/744a71c3d265d0e9a2ac25ca98dd0fa3ca68af6a))
+* **deps:** require google-auth>=1.25.0 ([744a71c](https://github.com/googleapis/python-bigquery-pandas/commit/744a71c3d265d0e9a2ac25ca98dd0fa3ca68af6a))
+* **deps:** require proto-plus>=1.15.0 ([744a71c](https://github.com/googleapis/python-bigquery-pandas/commit/744a71c3d265d0e9a2ac25ca98dd0fa3ca68af6a))
+
+## [0.17.2](https://github.com/googleapis/python-bigquery-pandas/compare/v0.17.1...v0.17.2) (2022-03-02)
+
+
+### Dependencies
+
+* allow pyarrow 7.0 ([#487](https://github.com/googleapis/python-bigquery-pandas/issues/487)) ([39441b6](https://github.com/googleapis/python-bigquery-pandas/commit/39441b63fadd95810c535e7079d781e9eec72189))
+
+## [0.17.1](https://github.com/googleapis/python-bigquery-pandas/compare/v0.17.0...v0.17.1) (2022-02-24)
+
+
+### Bug Fixes
+
+* avoid `TypeError` when executing DML statements with `read_gbq` ([#483](https://github.com/googleapis/python-bigquery-pandas/issues/483)) ([e9f0e3f](https://github.com/googleapis/python-bigquery-pandas/commit/e9f0e3f73f597530b8cf87324b9c4b0b54a79812))
+
+
+### Documentation
+
+* document additional breaking change in 0.17.0 ([#477](https://github.com/googleapis/python-bigquery-pandas/issues/477)) ([a858c80](https://github.com/googleapis/python-bigquery-pandas/commit/a858c80a37dc94707a41a6d865af2bc91543328a))
+
+## [0.17.0](https://github.com/googleapis/python-bigquery-pandas/compare/v0.16.0...v0.17.0) (2022-01-19)
+
+
+### ⚠ BREAKING CHANGES
+
+* the first argument of `read_gbq` is renamed from `query` to `query_or_table` ([#443](https://github.com/googleapis/python-bigquery-pandas/issues/443)) ([bf0e863](https://github.com/googleapis/python-bigquery-pandas/commit/bf0e863ff6506eca267b14e59e47417bd60e947f))
+* use nullable Int64 and boolean dtypes if available ([#445](https://github.com/googleapis/python-bigquery-pandas/issues/445)) ([89078f8](https://github.com/googleapis/python-bigquery-pandas/commit/89078f89478469aa60a0a8b8e1e0c4a59aa059e0))
+
+### Features
+
+* accepts a table ID, which downloads the table without a query ([#443](https://github.com/googleapis/python-bigquery-pandas/issues/443)) ([bf0e863](https://github.com/googleapis/python-bigquery-pandas/commit/bf0e863ff6506eca267b14e59e47417bd60e947f))
+* use nullable Int64 and boolean dtypes if available ([#445](https://github.com/googleapis/python-bigquery-pandas/issues/445)) ([89078f8](https://github.com/googleapis/python-bigquery-pandas/commit/89078f89478469aa60a0a8b8e1e0c4a59aa059e0))
+
+
+### Bug Fixes
+
+* `read_gbq` supports extreme DATETIME values such as `0001-01-01 00:00:00` ([#444](https://github.com/googleapis/python-bigquery-pandas/issues/444)) ([d120f8f](https://github.com/googleapis/python-bigquery-pandas/commit/d120f8fbdf4541a39ce8d87067523d48f21554bf))
+* `to_gbq` allows strings for DATE and floats for NUMERIC with `api_method="load_parquet"` ([#423](https://github.com/googleapis/python-bigquery-pandas/issues/423)) ([2180836](https://github.com/googleapis/python-bigquery-pandas/commit/21808367d02b5b7fcf35b3c7520224c819879aec))
+* allow extreme DATE values such as `datetime.date(1, 1, 1)` in `load_gbq` ([#442](https://github.com/googleapis/python-bigquery-pandas/issues/442)) ([e13abaf](https://github.com/googleapis/python-bigquery-pandas/commit/e13abaf015cd1ea9da3ad5063680bf89e18f0fac))
+* avoid iteritems deprecation in pandas prerelease ([#469](https://github.com/googleapis/python-bigquery-pandas/issues/469)) ([7379cdc](https://github.com/googleapis/python-bigquery-pandas/commit/7379cdcd7eedcbc751a4002bdf90c12e810e6bcd))
+* use data project for destination in `to_gbq` ([#455](https://github.com/googleapis/python-bigquery-pandas/issues/455)) ([891a00c](https://github.com/googleapis/python-bigquery-pandas/commit/891a00c8f202aa476ffb22b2fb92c01ffa84889a))
+
+
+### Miscellaneous Chores
+
+* release 0.17.0 ([#470](https://github.com/googleapis/python-bigquery-pandas/issues/470)) ([29ac8c3](https://github.com/googleapis/python-bigquery-pandas/commit/29ac8c33127457e86d9864a6979d532cd1d3ae5c))
+
+## [0.16.0](https://www.github.com/googleapis/python-bigquery-pandas/compare/v0.16.0...v0.16.0) (2021-11-08)
+
+
+### Features
+
+* `to_gbq` uses Parquet by default, use `api_method="load_csv"` for old behavior ([#413](https://www.github.com/googleapis/python-bigquery-pandas/issues/413)) ([9a65383](https://www.github.com/googleapis/python-bigquery-pandas/commit/9a65383916697ff02358aba58df555c85b16350c))
+* allow Python 3.10 ([#417](https://www.github.com/googleapis/python-bigquery-pandas/issues/417)) ([faba940](https://www.github.com/googleapis/python-bigquery-pandas/commit/faba940bc19d5c260b9dce3f973a9b729a179d20))
+
+
+### Miscellaneous Chores
+
+* release 0.16.0 ([#415](https://www.github.com/googleapis/python-bigquery-pandas/issues/415)) ([ea0f4e9](https://www.github.com/googleapis/python-bigquery-pandas/commit/ea0f4e97f3518895e824b1b7328d578081588d84))
+
+
+### Documentation
+
+* clarify `table_schema` ([#383](https://www.github.com/googleapis/python-bigquery-pandas/issues/383)) ([326e674](https://www.github.com/googleapis/python-bigquery-pandas/commit/326e674a24fc7e057e213596df92f0c4a8225f9e))
+
+## 0.15.0 / 2021-03-30
+
+### Features
+
+-   Load DataFrame with `to_gbq` to a table in a project different from
+    the API client project. Specify the target table ID as
+    `project.dataset.table` to use this feature.
+    ([#321](https://github.com/googleapis/python-bigquery-pandas/issues/321),
+    [#347](https://github.com/googleapis/python-bigquery-pandas/issues/347))
+-   Allow billing project to be separate from destination table project
+    in `to_gbq`.
+    ([#321](https://github.com/googleapis/python-bigquery-pandas/issues/321))
+
+### Bug fixes
+
+-   Avoid 403 error from `to_gbq` when table has `policyTags`.
+    ([#354](https://github.com/googleapis/python-bigquery-pandas/issues/354))
+-   Avoid `client.dataset` deprecation warnings.
+    ([#312](https://github.com/googleapis/python-bigquery-pandas/issues/312))
+
+### Dependencies
+
+-   Drop support for Python 3.5 and 3.6.
+    ([#337](https://github.com/googleapis/python-bigquery-pandas/issues/337))
+-   Drop support for <span
+    class="title-ref">google-cloud-bigquery==2.4.\*</span> due to query
+    hanging bug.
+    ([#343](https://github.com/googleapis/python-bigquery-pandas/issues/343))
+
+## 0.14.1 / 2020-11-10
+
+### Bug fixes
+
+-   Use `object` dtype for `TIME` columns.
+    ([#328](https://github.com/googleapis/python-bigquery-pandas/issues/328))
+-   Encode floating point values with greater precision.
+    ([#326](https://github.com/googleapis/python-bigquery-pandas/issues/326))
+-   Support `INT64` and other standard SQL aliases in
+    `~pandas_gbq.to_gbq` `table_schema` argument.
+    ([#322](https://github.com/googleapis/python-bigquery-pandas/issues/322))
+
+## 0.14.0 / 2020-10-05
+
+-   Add `dtypes` argument to `read_gbq`. Use this argument to override
+    the default `dtype` for a particular column in the query results.
+    For example, this can be used to select nullable integer columns as
+    the `Int64` nullable integer pandas extension type.
+    ([#242](https://github.com/googleapis/python-bigquery-pandas/issues/242),
+    [#332](https://github.com/googleapis/python-bigquery-pandas/issues/332))
+
+``` python
+df = gbq.read_gbq(
+    "SELECT CAST(NULL AS INT64) AS null_integer",
+    dtypes={"null_integer": "Int64"},
+)
+```
+
+### Dependency updates
+
+-   Support `google-cloud-bigquery-storage` 2.0 and higher.
+    ([#329](https://github.com/googleapis/python-bigquery-pandas/issues/329))
+-   Update the minimum version of `pandas` to 0.20.1.
+    ([#331](https://github.com/googleapis/python-bigquery-pandas/issues/331))
+
+### Internal changes
+
+-   Update tests to run against Python 3.8.
+    ([#331](https://github.com/googleapis/python-bigquery-pandas/issues/331))
+
+## 0.13.3 / 2020-09-30
+
+-   Include needed "extras" from `google-cloud-bigquery` package as
+    dependencies. Exclude incompatible 2.0 version.
+    ([#324](https://github.com/googleapis/python-bigquery-pandas/issues/324),
+    [#329](https://github.com/googleapis/python-bigquery-pandas/issues/329))
+
+## 0.13.2 / 2020-05-14
+
+-   Fix `Provided Schema does not match Table` error when the existing
+    table contains required fields.
+    ([#315](https://github.com/googleapis/python-bigquery-pandas/issues/315))
+
+## 0.13.1 / 2020-02-13
+
+-   Fix `AttributeError` with BQ Storage API to download empty results.
+    ([#299](https://github.com/googleapis/python-bigquery-pandas/issues/299))
+
+## 0.13.0 / 2019-12-12
+
+-   Raise `NotImplementedError` when the deprecated `private_key`
+    argument is used.
+    ([#301](https://github.com/googleapis/python-bigquery-pandas/issues/301))
+
+## 0.12.0 / 2019-11-25
+
+### New features
+
+-   Add `max_results` argument to `~pandas_gbq.read_gbq()`. Use this
+    argument to limit the number of rows in the results DataFrame. Set
+    `max_results` to 0 to ignore query outputs, such as for DML or DDL
+    queries.
+    ([#102](https://github.com/googleapis/python-bigquery-pandas/issues/102))
+-   Add `progress_bar_type` argument to `~pandas_gbq.read_gbq()`. Use
+    this argument to display a progress bar when downloading data.
+    ([#182](https://github.com/googleapis/python-bigquery-pandas/issues/182))
+
+### Bug fixes
+
+-   Fix resource leak with `use_bqstorage_api` by closing BigQuery
+    Storage API client after use.
+    ([#294](https://github.com/googleapis/python-bigquery-pandas/issues/294))
+
+### Dependency updates
+
+-   Update the minimum version of `google-cloud-bigquery` to 1.11.1.
+    ([#296](https://github.com/googleapis/python-bigquery-pandas/issues/296))
+
+### Documentation
+
+-   Add code samples to introduction and refactor howto guides.
+    ([#239](https://github.com/googleapis/python-bigquery-pandas/issues/239))
+
+## 0.11.0 / 2019-07-29
+
+-   **Breaking Change:** Python 2 support has been dropped. This is to
+    align with the pandas package which dropped Python 2 support at the
+    end of 2019.
+    ([#268](https://github.com/googleapis/python-bigquery-pandas/issues/268))
+
+### Enhancements
+
+-   Ensure `table_schema` argument is not modified inplace.
+    ([#278](https://github.com/googleapis/python-bigquery-pandas/issues/278))
+
+### Implementation changes
+
+-   Use object dtype for `STRING`, `ARRAY`, and `STRUCT` columns when
+    there are zero rows.
+    ([#285](https://github.com/googleapis/python-bigquery-pandas/issues/285))
+
+### Internal changes
+
+-   Populate `user-agent` with `pandas` version information.
+    ([#281](https://github.com/googleapis/python-bigquery-pandas/issues/281))
+-   Fix `pytest.raises` usage for latest pytest. Fix warnings in tests.
+    ([#282](https://github.com/googleapis/python-bigquery-pandas/issues/282))
+
+## 0.10.0 / 2019-04-05
+
+-   **Breaking Change:** Default SQL dialect is now `standard`. Use
+    `pandas_gbq.context.dialect` to override the default value.
+    ([#195](https://github.com/googleapis/python-bigquery-pandas/issues/195),
+    [#245](https://github.com/googleapis/python-bigquery-pandas/issues/245))
+
+### Documentation
+
+-   Document `BigQuery data type to pandas dtype conversion
+    <reading-dtypes>` for `read_gbq`.
+    ([#269](https://github.com/googleapis/python-bigquery-pandas/issues/269))
+
+### Dependency updates
+
+-   Update the minimum version of `google-cloud-bigquery` to 1.9.0.
+    ([#247](https://github.com/googleapis/python-bigquery-pandas/issues/247))
+-   Update the minimum version of `pandas` to 0.19.0.
+    ([#262](https://github.com/googleapis/python-bigquery-pandas/issues/262))
+
+### Internal changes
+
+-   Update the authentication credentials. **Note:** You may need to set
+    `reauth=True` in order to update your credentials to the most recent
+    version. This is required to use new functionality such as the
+    BigQuery Storage API.
+    ([#267](https://github.com/googleapis/python-bigquery-pandas/issues/267))
+-   Use `to_dataframe()` from `google-cloud-bigquery` in the
+    `read_gbq()` function.
+    ([#247](https://github.com/googleapis/python-bigquery-pandas/issues/247))
+
+### Enhancements
+
+-   Fix a bug where pandas-gbq could not upload an empty DataFrame.
+    ([#237](https://github.com/googleapis/python-bigquery-pandas/issues/237))
+-   Allow `table_schema` in `to_gbq` to contain only a subset of
+    columns, with the rest being populated using the DataFrame dtypes
+    ([#218](https://github.com/googleapis/python-bigquery-pandas/issues/218))
+    (contributed by @johnpaton)
+-   Read `project_id` in `to_gbq` from provided `credentials` if
+    available (contributed by @daureg)
+-   `read_gbq` uses the timezone-aware
+    `DatetimeTZDtype(unit='ns', tz='UTC')` dtype for BigQuery
+    `TIMESTAMP` columns.
+    ([#269](https://github.com/googleapis/python-bigquery-pandas/issues/269))
+-   Add `use_bqstorage_api` to `read_gbq`. The BigQuery Storage API can
+    be used to download large query results (>125 MB) more quickly. If
+    the BQ Storage API can't be used, the BigQuery API is used instead.
+    ([#133](https://github.com/googleapis/python-bigquery-pandas/issues/133),
+    [#270](https://github.com/googleapis/python-bigquery-pandas/issues/270))
+
+## 0.9.0 / 2019-01-11
+
+-   Warn when deprecated `private_key` parameter is used
+    ([#240](https://github.com/googleapis/python-bigquery-pandas/issues/240))
+-   **New dependency** Use the `pydata-google-auth` package for
+    authentication.
+    ([#241](https://github.com/googleapis/python-bigquery-pandas/issues/241))
+
+## 0.8.0 / 2018-11-12
+
+### Breaking changes
+
+-   **Deprecate** `private_key` parameter to `pandas_gbq.read_gbq` and
+    `pandas_gbq.to_gbq` in favor of new `credentials` argument. Instead,
+    create a credentials object using
+    `google.oauth2.service_account.Credentials.from_service_account_info`
+    or
+    `google.oauth2.service_account.Credentials.from_service_account_file`.
+    See the `authentication how-to guide <howto/authentication>` for
+    examples.
+    ([#161](https://github.com/googleapis/python-bigquery-pandas/issues/161),
+    [#231](https://github.com/googleapis/python-bigquery-pandas/issues/231))
+
+### Enhancements
+
+-   Allow newlines in data passed to `to_gbq`.
+    ([#180](https://github.com/googleapis/python-bigquery-pandas/issues/180))
+-   Add `pandas_gbq.context.dialect` to allow overriding the default SQL
+    syntax dialect.
+    ([#195](https://github.com/googleapis/python-bigquery-pandas/issues/195),
+    [#235](https://github.com/googleapis/python-bigquery-pandas/issues/235))
+-   Support Python 3.7.
+    ([#197](https://github.com/googleapis/python-bigquery-pandas/issues/197),
+    [#232](https://github.com/googleapis/python-bigquery-pandas/issues/232))
+
+### Internal changes
+
+-   Migrate tests to CircleCI.
+    ([#228](https://github.com/googleapis/python-bigquery-pandas/issues/228),
+    [#232](https://github.com/googleapis/python-bigquery-pandas/issues/232))
+
+## 0.7.0 / 2018-10-19
+
+-   <span class="title-ref">int</span> columns which contain <span
+    class="title-ref">NULL</span> are now cast to <span
+    class="title-ref">float</span>, rather than <span
+    class="title-ref">object</span> type.
+    ([#174](https://github.com/googleapis/python-bigquery-pandas/issues/174))
+-   <span class="title-ref">DATE</span>, <span
+    class="title-ref">DATETIME</span> and <span
+    class="title-ref">TIMESTAMP</span> columns are now parsed as pandas'
+    <span class="title-ref">timestamp</span> objects
+    ([#224](https://github.com/googleapis/python-bigquery-pandas/issues/224))
+-   Add `pandas_gbq.Context` to cache credentials in-memory, across
+    calls to `read_gbq` and `to_gbq`.
+    ([#198](https://github.com/googleapis/python-bigquery-pandas/issues/198),
+    [#208](https://github.com/googleapis/python-bigquery-pandas/issues/208))
+-   Fast queries now do not log above `DEBUG` level.
+    ([#204](https://github.com/googleapis/python-bigquery-pandas/issues/204))
+    With BigQuery's release of
+    [clustering](https://cloud.google.com/bigquery/docs/clustered-tables)
+    querying smaller samples of data is now faster and cheaper.
+-   Don't load credentials from disk if reauth is `True`.
+    ([#212](https://github.com/googleapis/python-bigquery-pandas/issues/212))
+    This fixes a bug where pandas-gbq could not refresh credentials if
+    the cached credentials were invalid, revoked, or expired, even when
+    `reauth=True`.
+-   Catch RefreshError when trying credentials.
+    ([#226](https://github.com/googleapis/python-bigquery-pandas/issues/226))
+
+### Internal changes
+
+-   Avoid listing datasets and tables in system tests.
+    ([#215](https://github.com/googleapis/python-bigquery-pandas/issues/215))
+-   Improved performance from eliminating some duplicative parsing steps
+    ([#224](https://github.com/googleapis/python-bigquery-pandas/issues/224))
+
+## 0.6.1 / 2018-09-11
+
+-   Improved `read_gbq` performance and memory consumption by delegating
+    `DataFrame` construction to the Pandas library, radically reducing
+    the number of loops that execute in python
+    ([#128](https://github.com/googleapis/python-bigquery-pandas/issues/128))
+-   Reduced verbosity of logging from `read_gbq`, particularly for short
+    queries.
+    ([#201](https://github.com/googleapis/python-bigquery-pandas/issues/201))
+-   Avoid `SELECT 1` query when running `to_gbq`.
+    ([#202](https://github.com/googleapis/python-bigquery-pandas/issues/202))
+
+## 0.6.0 / 2018-08-15
+
+-   Warn when `dialect` is not passed in to `read_gbq`. The default
+    dialect will be changing from 'legacy' to 'standard' in a future
+    version.
+    ([#195](https://github.com/googleapis/python-bigquery-pandas/issues/195))
+-   Use general float with 15 decimal digit precision when writing to
+    local CSV buffer in `to_gbq`. This prevents numerical overflow in
+    certain edge cases.
+    ([#192](https://github.com/googleapis/python-bigquery-pandas/issues/192))
+
+## 0.5.0 / 2018-06-15
+
+-   Project ID parameter is optional in `read_gbq` and `to_gbq` when it
+    can inferred from the environment. Note: you must still pass in a
+    project ID when using user-based authentication.
+    ([#103](https://github.com/googleapis/python-bigquery-pandas/issues/103))
+-   Progress bar added for `to_gbq`, through an optional library <span
+    class="title-ref">tqdm</span> as dependency.
+    ([#162](https://github.com/googleapis/python-bigquery-pandas/issues/162))
+-   Add location parameter to `read_gbq` and `to_gbq` so that pandas-gbq
+    can work with datasets in the Tokyo region.
+    ([#177](https://github.com/googleapis/python-bigquery-pandas/issues/177))
+
+### Documentation
+
+-   Add `authentication how-to guide <howto/authentication>`.
+    ([#183](https://github.com/googleapis/python-bigquery-pandas/issues/183))
+-   Update `contributing` guide with new paths to tests.
+    ([#154](https://github.com/googleapis/python-bigquery-pandas/issues/154),
+    [#164](https://github.com/googleapis/python-bigquery-pandas/issues/164))
+
+### Internal changes
+
+-   Tests now use <span class="title-ref">nox</span> to run in multiple
+    Python environments.
+    ([#52](https://github.com/googleapis/python-bigquery-pandas/issues/52))
+-   Renamed internal modules.
+    ([#154](https://github.com/googleapis/python-bigquery-pandas/issues/154))
+-   Refactored auth to an internal auth module.
+    ([#176](https://github.com/googleapis/python-bigquery-pandas/issues/176))
+-   Add unit tests for `get_credentials()`.
+    ([#184](https://github.com/googleapis/python-bigquery-pandas/issues/184))
+
+## 0.4.1 / 2018-04-05
+
+-   Only show `verbose` deprecation warning if Pandas version does not
+    populate it.
+    ([#157](https://github.com/googleapis/python-bigquery-pandas/issues/157))
+
+## 0.4.0 / 2018-04-03
+
+-   Fix bug in <span class="title-ref">read_gbq</span> when building a
+    dataframe with integer columns on Windows. Explicitly use 64bit
+    integers when converting from BQ types.
+    ([#119](https://github.com/googleapis/python-bigquery-pandas/issues/119))
+-   Fix bug in <span class="title-ref">read_gbq</span> when querying for
+    an array of floats
+    ([#123](https://github.com/googleapis/python-bigquery-pandas/issues/123))
+-   Fix bug in <span class="title-ref">read_gbq</span> with
+    configuration argument. Updates <span
+    class="title-ref">read_gbq</span> to account for breaking change in
+    the way `google-cloud-python` version 0.32.0+ handles query
+    configuration API representation.
+    ([#152](https://github.com/googleapis/python-bigquery-pandas/issues/152))
+-   Fix bug in <span class="title-ref">to_gbq</span> where seconds were
+    discarded in timestamp columns.
+    ([#148](https://github.com/googleapis/python-bigquery-pandas/issues/148))
+-   Fix bug in <span class="title-ref">to_gbq</span> when supplying a
+    user-defined schema
+    ([#150](https://github.com/googleapis/python-bigquery-pandas/issues/150))
+-   **Deprecate** the `verbose` parameter in <span
+    class="title-ref">read_gbq</span> and <span
+    class="title-ref">to_gbq</span>. Messages use the logging module
+    instead of printing progress directly to standard output.
+    ([#12](https://github.com/googleapis/python-bigquery-pandas/issues/12))
+
+## 0.3.1 / 2018-02-13
+
+-   Fix an issue where Unicode couldn't be uploaded in Python 2
+    ([#106](https://github.com/googleapis/python-bigquery-pandas/issues/106))
+-   Add support for a passed schema in `` `to_gbq ``<span
+    class="title-ref"> instead inferring the schema from the passed
+    </span><span class="title-ref">DataFrame</span><span
+    class="title-ref"> with </span><span
+    class="title-ref">DataFrame.dtypes</span><span class="title-ref">
+    (</span>#46
+    \<<https://github.com/googleapis/python-bigquery-pandas/issues/46>\>\`\_)
+-   Fix an issue where a dataframe containing both integer and floating
+    point columns could not be uploaded with `to_gbq`
+    ([#116](https://github.com/googleapis/python-bigquery-pandas/issues/116))
+-   `to_gbq` now uses `to_csv` to avoid manually looping over rows in a
+    dataframe (should result in faster table uploads)
+    ([#96](https://github.com/googleapis/python-bigquery-pandas/issues/96))
+
+## 0.3.0 / 2018-01-03
+
+-   Use the
+    [google-cloud-bigquery](https://googlecloudplatform.github.io/google-cloud-python/latest/bigquery/usage.html)
+    library for API calls. The `google-cloud-bigquery` package is a new
+    dependency, and dependencies on `google-api-python-client` and
+    `httplib2` are removed. See the [installation
+    guide](https://pandas-gbq.readthedocs.io/en/latest/install.html#dependencies)
+    for more details.
+    ([#93](https://github.com/googleapis/python-bigquery-pandas/issues/93))
+-   Structs and arrays are now named properly
+    ([#23](https://github.com/googleapis/python-bigquery-pandas/issues/23))
+    and BigQuery functions like `array_agg` no longer run into errors
+    during type conversion
+    ([#22](https://github.com/googleapis/python-bigquery-pandas/issues/22)).
+-   `to_gbq` now uses a load job instead of the streaming API. Remove
+    `StreamingInsertError` class, as it is no longer used by `to_gbq`.
+    ([#7](https://github.com/googleapis/python-bigquery-pandas/issues/7),
+    [#75](https://github.com/googleapis/python-bigquery-pandas/issues/75))
+
+## 0.2.1 / 2017-11-27
+
+-   `read_gbq` now raises `QueryTimeout` if the request exceeds the
+    `query.timeoutMs` value specified in the BigQuery configuration.
+    ([#76](https://github.com/googleapis/python-bigquery-pandas/issues/76))
+-   Environment variable `PANDAS_GBQ_CREDENTIALS_FILE` can now be used
+    to override the default location where the BigQuery user account
+    credentials are stored.
+    ([#86](https://github.com/googleapis/python-bigquery-pandas/issues/86))
+-   BigQuery user account credentials are now stored in an
+    application-specific hidden user folder on the operating system.
+    ([#41](https://github.com/googleapis/python-bigquery-pandas/issues/41))
+
+## 0.2.0 / 2017-07-24
+
+-   Drop support for Python 3.4
+    ([#40](https://github.com/googleapis/python-bigquery-pandas/issues/40))
+-   The dataframe passed to
+    `` `.to_gbq(...., if_exists='append') ``<span class="title-ref">
+    needs to contain only a subset of the fields in the BigQuery schema.
+    (</span>#24
+    \<<https://github.com/googleapis/python-bigquery-pandas/issues/24>\>\`\_)
+-   Use the [google-auth](https://google-auth.readthedocs.io/en/latest/)
+    library for authentication because `oauth2client` is deprecated.
+    ([#39](https://github.com/googleapis/python-bigquery-pandas/issues/39))
+-   `read_gbq` now has a `auth_local_webserver` boolean argument for
+    controlling whether to use web server or console flow when getting
+    user credentials. Replaces <span
+    class="title-ref">--noauth_local_webserver</span> command line
+    argument.
+    ([#35](https://github.com/googleapis/python-bigquery-pandas/issues/35))
+-   `read_gbq` now displays the BigQuery Job ID and standard price in
+    verbose output.
+    ([#70](https://github.com/googleapis/python-bigquery-pandas/issues/70)
+    and
+    [#71](https://github.com/googleapis/python-bigquery-pandas/issues/71))
+
+## 0.1.6 / 2017-05-03
+
+-   All gbq errors will simply be subclasses of `ValueError` and no
+    longer inherit from the deprecated `PandasError`.
+
+## 0.1.4 / 2017-03-17
+
+-   `InvalidIndexColumn` will be raised instead of `InvalidColumnOrder`
+    in `read_gbq` when the index column specified does not exist in the
+    BigQuery schema.
+    ([#6](https://github.com/googleapis/python-bigquery-pandas/issues/6))
+
+## 0.1.3 / 2017-03-04
+
+-   Bug with appending to a BigQuery table where fields have modes
+    (NULLABLE,REQUIRED,REPEATED) specified. These modes were compared
+    versus the remote schema and writing a table via `to_gbq` would
+    previously raise.
+    ([#13](https://github.com/googleapis/python-bigquery-pandas/issues/13))
+
+## 0.1.2 / 2017-02-23
+
+Initial release of transfered code from
+[pandas](https://github.com/pandas-dev/pandas)
+
+Includes patches since the 0.19.2 release on pandas with the following:
+
+-   `read_gbq` now allows query configuration preferences
+    [pandas-GH#14742](https://github.com/pandas-dev/pandas/pull/14742)
+-   `read_gbq` now stores `INTEGER` columns as `dtype=object` if they
+    contain `NULL` values. Otherwise they are stored as `int64`. This
+    prevents precision lost for integers greather than 2\**53.
+    Furthermore \`\`FLOAT\`\` columns with values above 10*\*4 are no
+    longer casted to `int64` which also caused precision loss
+    [pandas-GH#14064](https://github.com/pandas-dev/pandas/pull/14064),
+    and
+    [pandas-GH#14305](https://github.com/pandas-dev/pandas/pull/14305)
diff --git a/packages/pandas-gbq/CODE_OF_CONDUCT.md b/packages/pandas-gbq/CODE_OF_CONDUCT.md
new file mode 100644
index 000000000000..039f43681204
--- /dev/null
+++ b/packages/pandas-gbq/CODE_OF_CONDUCT.md
@@ -0,0 +1,95 @@
+<!-- # Generated by synthtool. DO NOT EDIT! !-->
+# Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as
+contributors and maintainers pledge to making participation in our project and
+our community a harassment-free experience for everyone, regardless of age, body
+size, disability, ethnicity, gender identity and expression, level of
+experience, education, socio-economic status, nationality, personal appearance,
+race, religion, or sexual identity and orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment
+include:
+
+*   Using welcoming and inclusive language
+*   Being respectful of differing viewpoints and experiences
+*   Gracefully accepting constructive criticism
+*   Focusing on what is best for the community
+*   Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+*   The use of sexualized language or imagery and unwelcome sexual attention or
+    advances
+*   Trolling, insulting/derogatory comments, and personal or political attacks
+*   Public or private harassment
+*   Publishing others' private information, such as a physical or electronic
+    address, without explicit permission
+*   Other conduct which could reasonably be considered inappropriate in a
+    professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable
+behavior and are expected to take appropriate and fair corrective action in
+response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or reject
+comments, commits, code, wiki edits, issues, and other contributions that are
+not aligned to this Code of Conduct, or to ban temporarily or permanently any
+contributor for other behaviors that they deem inappropriate, threatening,
+offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community. Examples of
+representing a project or community include using an official project e-mail
+address, posting via an official social media account, or acting as an appointed
+representative at an online or offline event. Representation of a project may be
+further defined and clarified by project maintainers.
+
+This Code of Conduct also applies outside the project spaces when the Project
+Steward has a reasonable belief that an individual's behavior may have a
+negative impact on the project or its community.
+
+## Conflict Resolution
+
+We do not believe that all conflict is bad; healthy debate and disagreement
+often yield positive results. However, it is never okay to be disrespectful or
+to engage in behavior that violates the project’s code of conduct.
+
+If you see someone violating the code of conduct, you are encouraged to address
+the behavior directly with those involved. Many issues can be resolved quickly
+and easily, and this gives people more control over the outcome of their
+dispute. If you are unable to resolve the matter for any reason, or if the
+behavior is threatening or harassing, report it. We are dedicated to providing
+an environment where participants feel welcome and safe.
+
+
+Reports should be directed to *googleapis-stewards@google.com*, the
+Project Steward(s) for *Google Cloud Client Libraries*. It is the Project Steward’s duty to
+receive and address reported violations of the code of conduct. They will then
+work with a committee consisting of representatives from the Open Source
+Programs Office and the Google Open Source Strategy team. If for any reason you
+are uncomfortable reaching out to the Project Steward, please email
+opensource@google.com.
+
+We will investigate every complaint, but you may not receive a direct response.
+We will use our discretion in determining when and how to follow up on reported
+incidents, which may range from not taking action to permanent expulsion from
+the project and project-sponsored spaces. We will notify the accused of the
+report and provide them an opportunity to discuss it before any action is taken.
+The identity of the reporter will be omitted from the details of the report
+supplied to the accused. In potentially harmful situations, such as ongoing
+harassment or threats to anyone's safety, we may take action without notice.
+
+## Attribution
+
+This Code of Conduct is adapted from the Contributor Covenant, version 1.4,
+available at
+https://www.contributor-covenant.org/version/1/4/code-of-conduct.html
\ No newline at end of file
diff --git a/packages/pandas-gbq/CONTRIBUTING.rst b/packages/pandas-gbq/CONTRIBUTING.rst
new file mode 100644
index 000000000000..2e8e9860f4f5
--- /dev/null
+++ b/packages/pandas-gbq/CONTRIBUTING.rst
@@ -0,0 +1,281 @@
+.. Generated by synthtool. DO NOT EDIT!
+############
+Contributing
+############
+
+#. **Please sign one of the contributor license agreements below.**
+#. Fork the repo, develop and test your code changes, add docs.
+#. Make sure that your commit messages clearly describe the changes.
+#. Send a pull request. (Please Read: `Faster Pull Request Reviews`_)
+
+.. _Faster Pull Request Reviews: https://github.com/kubernetes/community/blob/master/contributors/guide/pull-requests.md#best-practices-for-faster-reviews
+
+.. contents:: Here are some guidelines for hacking on the Google Cloud Client libraries.
+
+***************
+Adding Features
+***************
+
+In order to add a feature:
+
+- The feature must be documented in both the API and narrative
+  documentation.
+
+- The feature must work fully on the following CPython versions:
+  3.9, 3.10, 3.11, 3.12 and 3.13 on both UNIX and Windows.
+
+- The feature must not add unnecessary dependencies (where
+  "unnecessary" is of course subjective, but new dependencies should
+  be discussed).
+
+****************************
+Using a Development Checkout
+****************************
+
+You'll have to create a development environment using a Git checkout:
+
+- While logged into your GitHub account, navigate to the
+  ``python-bigquery-pandas`` `repo`_ on GitHub.
+
+- Fork and clone the ``python-bigquery-pandas`` repository to your GitHub account by
+  clicking the "Fork" button.
+
+- Clone your fork of ``python-bigquery-pandas`` from your GitHub account to your local
+  computer, substituting your account username and specifying the destination
+  as ``hack-on-python-bigquery-pandas``.  E.g.::
+
+   $ cd ${HOME}
+   $ git clone git@github.com:USERNAME/python-bigquery-pandas.git hack-on-python-bigquery-pandas
+   $ cd hack-on-python-bigquery-pandas
+   # Configure remotes such that you can pull changes from the googleapis/python-bigquery-pandas
+   # repository into your local repository.
+   $ git remote add upstream git@github.com:googleapis/python-bigquery-pandas.git
+   # fetch and merge changes from upstream into main
+   $ git fetch upstream
+   $ git merge upstream/main
+
+Now your local repo is set up such that you will push changes to your GitHub
+repo, from which you can submit a pull request.
+
+To work on the codebase and run the tests, we recommend using ``nox``,
+but you can also use a ``virtualenv`` of your own creation.
+
+.. _repo: https://github.com/googleapis/python-bigquery-pandas
+
+Using ``nox``
+=============
+
+We use `nox <https://nox.readthedocs.io/en/latest/>`__ to instrument our tests.
+
+- To test your changes, run unit tests with ``nox``::
+    $ nox -s unit
+
+- To run a single unit test::
+
+    $ nox -s unit-3.13 -- -k <name of test>
+
+
+  .. note::
+
+    The unit tests and system tests are described in the
+    ``noxfile.py`` files in each directory.
+
+.. nox: https://pypi.org/project/nox/
+
+*****************************************
+I'm getting weird errors... Can you help?
+*****************************************
+
+If the error mentions ``Python.h`` not being found,
+install ``python-dev`` and try again.
+On Debian/Ubuntu::
+
+  $ sudo apt-get install python-dev
+
+************
+Coding Style
+************
+- We use the automatic code formatter ``black``. You can run it using
+  the nox session ``blacken``. This will eliminate many lint errors. Run via::
+
+   $ nox -s blacken
+
+- PEP8 compliance is required, with exceptions defined in the linter configuration.
+  If you have ``nox`` installed, you can test that you have not introduced
+  any non-compliant code via::
+
+   $ nox -s lint
+
+- In order to make ``nox -s lint`` run faster, you can set some environment
+  variables::
+
+   export GOOGLE_CLOUD_TESTING_REMOTE="upstream"
+   export GOOGLE_CLOUD_TESTING_BRANCH="main"
+
+  By doing this, you are specifying the location of the most up-to-date
+  version of ``python-bigquery-pandas``. The
+  remote name ``upstream`` should point to the official ``googleapis``
+  checkout and the branch should be the default branch on that remote (``main``).
+
+- This repository contains configuration for the
+  `pre-commit <https://pre-commit.com/>`__ tool, which automates checking
+  our linters during a commit.  If you have it installed on your ``$PATH``,
+  you can enable enforcing those checks via:
+
+.. code-block:: bash
+
+   $ pre-commit install
+   pre-commit installed at .git/hooks/pre-commit
+
+Exceptions to PEP8:
+
+- Many unit tests use a helper method, ``_call_fut`` ("FUT" is short for
+  "Function-Under-Test"), which is PEP8-incompliant, but more readable.
+  Some also use a local variable, ``MUT`` (short for "Module-Under-Test").
+
+********************
+Running System Tests
+********************
+
+- To run system tests, you can execute::
+
+   # Run all system tests
+   $ nox -s system
+
+   # Run a single system test
+   $ nox -s system-3.13 -- -k <name of test>
+
+
+  .. note::
+
+      System tests are only configured to run under Python 3.9, 3.10, 3.11, 3.12 and 3.13.
+      For expediency, we do not run them in older versions of Python 3.
+
+  This alone will not run the tests. You'll need to change some local
+  auth settings and change some configuration in your project to
+  run all the tests.
+
+- System tests will be run against an actual project. You should use local credentials from gcloud when possible. See `Best practices for application authentication <https://cloud.google.com/docs/authentication/best-practices-applications#local_development_and_testing_with_the>`__. Some tests require a service account. For those tests see `Authenticating as a service account <https://cloud.google.com/docs/authentication/production>`__.
+
+*************
+Test Coverage
+*************
+
+- The codebase *must* have 100% test statement coverage after each commit.
+  You can test coverage via ``nox -s cover``.
+
+******************************************************
+Documentation Coverage and Building HTML Documentation
+******************************************************
+
+If you fix a bug, and the bug requires an API or behavior modification, all
+documentation in this package which references that API or behavior must be
+changed to reflect the bug fix, ideally in the same commit that fixes the bug
+or adds the feature.
+
+Build the docs via:
+
+   $ nox -s docs
+
+*************************
+Samples and code snippets
+*************************
+
+Code samples and snippets live in the `samples/` catalogue. Feel free to
+provide more examples, but make sure to write tests for those examples.
+Each folder containing example code requires its own `noxfile.py` script
+which automates testing. If you decide to create a new folder, you can
+base it on the `samples/snippets` folder (providing `noxfile.py` and
+the requirements files).
+
+The tests will run against a real Google Cloud Project, so you should
+configure them just like the System Tests.
+
+- To run sample tests, you can execute::
+
+   # Run all tests in a folder
+   $ cd samples/snippets
+   $ nox -s py-3.8
+
+   # Run a single sample test
+   $ cd samples/snippets
+   $ nox -s py-3.8 -- -k <name of test>
+
+********************************************
+Note About ``README`` as it pertains to PyPI
+********************************************
+
+The `description on PyPI`_ for the project comes directly from the
+``README``. Due to the reStructuredText (``rst``) parser used by
+PyPI, relative links which will work on GitHub (e.g. ``CONTRIBUTING.rst``
+instead of
+``https://github.com/googleapis/python-bigquery-pandas/blob/main/CONTRIBUTING.rst``)
+may cause problems creating links or rendering the description.
+
+.. _description on PyPI: https://pypi.org/project/pandas-gbq
+
+
+*************************
+Supported Python Versions
+*************************
+
+We support:
+
+-  `Python 3.9`_
+-  `Python 3.10`_
+-  `Python 3.11`_
+-  `Python 3.12`_
+-  `Python 3.13`_
+
+.. _Python 3.9: https://docs.python.org/3.9/
+.. _Python 3.10: https://docs.python.org/3.10/
+.. _Python 3.11: https://docs.python.org/3.11/
+.. _Python 3.12: https://docs.python.org/3.12/
+.. _Python 3.13: https://docs.python.org/3.13/
+
+
+Supported versions can be found in our ``noxfile.py`` `config`_.
+
+.. _config: https://github.com/googleapis/python-bigquery-pandas/blob/main/noxfile.py
+
+
+We also explicitly decided to support Python 3 beginning with version 3.9.
+Reasons for this include:
+
+-  Encouraging use of newest versions of Python 3
+-  Taking the lead of `prominent`_ open-source `projects`_
+-  `Unicode literal support`_ which allows for a cleaner codebase that
+   works in both Python 2 and Python 3
+
+.. _prominent: https://docs.djangoproject.com/en/1.9/faq/install/#what-python-version-can-i-use-with-django
+.. _projects: http://flask.pocoo.org/docs/0.10/python3/
+.. _Unicode literal support: https://www.python.org/dev/peps/pep-0414/
+
+**********
+Versioning
+**********
+
+This library follows `Semantic Versioning`_.
+
+.. _Semantic Versioning: http://semver.org/
+
+Some packages are currently in major version zero (``0.y.z``), which means that
+anything may change at any time and the public API should not be considered
+stable.
+
+******************************
+Contributor License Agreements
+******************************
+
+Before we can accept your pull requests you'll need to sign a Contributor
+License Agreement (CLA):
+
+- **If you are an individual writing original source code** and **you own the
+  intellectual property**, then you'll need to sign an
+  `individual CLA <https://developers.google.com/open-source/cla/individual>`__.
+- **If you work for a company that wants to allow you to contribute your work**,
+  then you'll need to sign a
+  `corporate CLA <https://developers.google.com/open-source/cla/corporate>`__.
+
+You can sign these electronically (just scroll to the bottom). After that,
+we'll be able to accept your pull requests.
diff --git a/packages/pandas-gbq/LICENSE.txt b/packages/pandas-gbq/LICENSE.txt
new file mode 100644
index 000000000000..924de26253bf
--- /dev/null
+++ b/packages/pandas-gbq/LICENSE.txt
@@ -0,0 +1,29 @@
+BSD 3-Clause License
+
+Copyright (c) 2008-2012, AQR Capital Management, LLC, Lambda Foundry, Inc. and PyData Development Team
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+* Neither the name of the copyright holder nor the names of its
+  contributors may be used to endorse or promote products derived from
+  this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/packages/pandas-gbq/MANIFEST.in b/packages/pandas-gbq/MANIFEST.in
new file mode 100644
index 000000000000..d6814cd60037
--- /dev/null
+++ b/packages/pandas-gbq/MANIFEST.in
@@ -0,0 +1,25 @@
+# -*- coding: utf-8 -*-
+#
+# 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.
+
+# Generated by synthtool. DO NOT EDIT!
+include README.rst LICENSE
+recursive-include google *.json *.proto py.typed
+recursive-include tests *
+global-exclude *.py[co]
+global-exclude __pycache__
+
+# Exclude scripts for samples readmegen
+prune scripts/readme-gen
diff --git a/packages/pandas-gbq/README.rst b/packages/pandas-gbq/README.rst
new file mode 100644
index 000000000000..122f43ee09e8
--- /dev/null
+++ b/packages/pandas-gbq/README.rst
@@ -0,0 +1,62 @@
+pandas-gbq
+==========
+
+|preview| |pypi| |versions|
+
+**pandas-gbq** is a package providing an interface to the Google BigQuery API from pandas.
+
+-  `Library Documentation`_
+-  `Product Documentation`_
+
+.. |preview| image:: https://img.shields.io/badge/support-preview-orange.svg
+   :target: https://github.com/googleapis/google-cloud-python/blob/main/README.rst#beta-support
+.. |pypi| image:: https://img.shields.io/pypi/v/pandas-gbq.svg
+   :target: https://pypi.org/project/pandas-gbq/
+.. |versions| image:: https://img.shields.io/pypi/pyversions/pandas-gbq.svg
+   :target: https://pypi.org/project/pandas-gbq/
+.. _Library Documentation: https://googleapis.dev/python/pandas-gbq/latest/
+.. _Product Documentation: https://cloud.google.com/bigquery/docs/reference/v2/
+
+Installation
+------------
+
+Install latest release version via pip
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+.. code-block:: shell
+
+   $ pip install pandas-gbq
+
+Install latest development version
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+.. code-block:: shell
+
+    $ pip install git+https://github.com/googleapis/python-bigquery-pandas.git
+
+
+Usage
+-----
+
+Perform a query
+~~~~~~~~~~~~~~~
+
+.. code:: python
+
+    import pandas_gbq
+
+    result_dataframe = pandas_gbq.read_gbq("SELECT column FROM dataset.table WHERE value = 'something'")
+
+Upload a dataframe
+~~~~~~~~~~~~~~~~~~
+
+.. code:: python
+
+    import pandas_gbq
+
+    pandas_gbq.to_gbq(dataframe, "dataset.table")
+
+More samples
+~~~~~~~~~~~~
+
+See the `pandas-gbq documentation <https://googleapis.dev/python/pandas-gbq/latest/>`_ for more details.
diff --git a/packages/pandas-gbq/ROADMAP.md b/packages/pandas-gbq/ROADMAP.md
new file mode 100644
index 000000000000..d4053cfa5279
--- /dev/null
+++ b/packages/pandas-gbq/ROADMAP.md
@@ -0,0 +1,57 @@
+# pandas-gbq Roadmap
+
+The purpose of this package is to provide a small subset of BigQuery
+functionality that maps well to
+[pandas.read_gbq](https://pandas.pydata.org/docs/reference/api/pandas.read_gbq.html#pandas.read_gbq)
+and
+[pandas.DataFrame.to_gbq](https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.to_gbq.html#pandas.DataFrame.to_gbq).
+Those methods in the pandas library are a thin wrapper to the equivalent
+methods in this package.
+
+## Adding features to pandas-gbq
+
+Considerations when adding new features to pandas-gbq:
+
+* New method? Consider an alternative, as the core focus of this library is
+  `read_gbq` and `to_gbq`.
+* Breaking change to an existing parameter? Consider an alternative, as folks
+  could be using an older version of `pandas` that doesn't account for the
+  change when a newer version of `pandas-gbq` is installed. If you must, please
+  follow a 1+ year deprecation timeline.
+* New parameter? Go for it! Be sure to also send a PR to `pandas` after the
+  feature is released so that folks using the `pandas` wrapper can take
+  advantage of it.
+* New data type? OK. If there's not a good mapping to an existing `pandas`
+  dtype, consider adding one to the `db-dtypes` package.
+
+## Vision
+
+The `pandas-gbq` package should do the "right thing" by default. This means you
+should carefully choose dtypes for maximum compatibility with BigQuery and
+avoid data loss. As new data types are added to BigQuery that don't have good
+equivalents yet in the `pandas` ecosystem, equivalent dtypes should be added to
+the `db-dtypes` package.
+
+As new features are added that might improve performance, `pandas-gbq` should
+offer easy ways to use them without sacrificing usability. For example, one
+might consider using the `api_method` parameter of `to_gbq` to support the
+BigQuery Storage Write API.
+
+A note on `pandas.read_sql`: we'd like to be compatible with this too, for folks
+that need better performance compared to the SQLAlchemy connector.
+
+## Usability
+
+Unlike the more object-oriented client-libraries, it's natural to have a method
+with many parameters in the Python data science ecosystem. That said, the
+`configuration` argument is provided, which takes the REST representation of
+the job configuration so that power users can use new features without the need
+for an explicit parameter being added.
+
+## Conclusion
+
+Keep it simple.
+
+Don't break existing users.
+
+Do the right thing by default.
diff --git a/packages/pandas-gbq/SECURITY.md b/packages/pandas-gbq/SECURITY.md
new file mode 100644
index 000000000000..8b58ae9c01ae
--- /dev/null
+++ b/packages/pandas-gbq/SECURITY.md
@@ -0,0 +1,7 @@
+# Security Policy
+
+To report a security issue, please use [g.co/vulnz](https://g.co/vulnz).
+
+The Google Security Team will respond within 5 working days of your report on g.co/vulnz.
+
+We use g.co/vulnz for our intake, and do coordination and disclosure here using GitHub Security Advisory to privately discuss and fix the issue.
diff --git a/packages/pandas-gbq/benchmark/README.md b/packages/pandas-gbq/benchmark/README.md
new file mode 100644
index 000000000000..5ede71d709bf
--- /dev/null
+++ b/packages/pandas-gbq/benchmark/README.md
@@ -0,0 +1,16 @@
+# pandas-gbq benchmarks
+
+This directory contains a few scripts which are useful for performance
+testing the pandas-gbq library. Use cProfile to time the script and see
+details about where time is spent. To avoid timing how long BigQuery takes to
+execute a query, run the benchmark twice to ensure the results are cached.
+
+## `read_gbq`
+
+Read a small table (a few KB).
+
+    python -m cProfile --sort=cumtime read_gbq_small_results.py
+
+Read a large-ish table (100+ MB).
+
+    python -m cProfile --sort=cumtime read_gbq_large_results.py
diff --git a/packages/pandas-gbq/benchmark/read_gbq_large_results.py b/packages/pandas-gbq/benchmark/read_gbq_large_results.py
new file mode 100644
index 000000000000..6a1d68cece58
--- /dev/null
+++ b/packages/pandas-gbq/benchmark/read_gbq_large_results.py
@@ -0,0 +1,12 @@
+# Copyright (c) 2017 pandas-gbq Authors All rights reserved.
+# Use of this source code is governed by a BSD-style
+# license that can be found in the LICENSE file.
+
+import pandas_gbq
+
+# Select 163 MB worth of data, to time how long it takes to download large
+# result sets.
+df = pandas_gbq.read_gbq(
+    "SELECT * FROM `bigquery-public-data.usa_names.usa_1910_2013`",
+    dialect="standard",
+)
diff --git a/packages/pandas-gbq/benchmark/read_gbq_small_results.py b/packages/pandas-gbq/benchmark/read_gbq_small_results.py
new file mode 100644
index 000000000000..f90d3c7b2c30
--- /dev/null
+++ b/packages/pandas-gbq/benchmark/read_gbq_small_results.py
@@ -0,0 +1,11 @@
+# Copyright (c) 2017 pandas-gbq Authors All rights reserved.
+# Use of this source code is governed by a BSD-style
+# license that can be found in the LICENSE file.
+
+import pandas_gbq
+
+# Select a few KB worth of data, to time downloading small result sets.
+df = pandas_gbq.read_gbq(
+    "SELECT * FROM `bigquery-public-data.utility_us.country_code_iso`",
+    dialect="standard",
+)
diff --git a/packages/pandas-gbq/docs/Makefile b/packages/pandas-gbq/docs/Makefile
new file mode 100644
index 000000000000..cd87dd5ef7a6
--- /dev/null
+++ b/packages/pandas-gbq/docs/Makefile
@@ -0,0 +1,225 @@
+# Makefile for Sphinx documentation
+#
+
+# You can set these variables from the command line.
+SPHINXOPTS    =
+SPHINXBUILD   = sphinx-build
+PAPER         =
+BUILDDIR      = _build
+
+# Internal variables.
+PAPEROPT_a4     = -D latex_paper_size=a4
+PAPEROPT_letter = -D latex_paper_size=letter
+ALLSPHINXOPTS   = -d $(BUILDDIR)/doctrees $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) .
+# the i18n builder cannot share the environment and doctrees with the others
+I18NSPHINXOPTS  = $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) .
+
+.PHONY: help
+help:
+	@echo "Please use \`make <target>' where <target> is one of"
+	@echo "  html       to make standalone HTML files"
+	@echo "  dirhtml    to make HTML files named index.html in directories"
+	@echo "  singlehtml to make a single large HTML file"
+	@echo "  pickle     to make pickle files"
+	@echo "  json       to make JSON files"
+	@echo "  htmlhelp   to make HTML files and a HTML help project"
+	@echo "  qthelp     to make HTML files and a qthelp project"
+	@echo "  applehelp  to make an Apple Help Book"
+	@echo "  devhelp    to make HTML files and a Devhelp project"
+	@echo "  epub       to make an epub"
+	@echo "  epub3      to make an epub3"
+	@echo "  latex      to make LaTeX files, you can set PAPER=a4 or PAPER=letter"
+	@echo "  latexpdf   to make LaTeX files and run them through pdflatex"
+	@echo "  latexpdfja to make LaTeX files and run them through platex/dvipdfmx"
+	@echo "  text       to make text files"
+	@echo "  man        to make manual pages"
+	@echo "  texinfo    to make Texinfo files"
+	@echo "  info       to make Texinfo files and run them through makeinfo"
+	@echo "  gettext    to make PO message catalogs"
+	@echo "  changes    to make an overview of all changed/added/deprecated items"
+	@echo "  xml        to make Docutils-native XML files"
+	@echo "  pseudoxml  to make pseudoxml-XML files for display purposes"
+	@echo "  linkcheck  to check all external links for integrity"
+	@echo "  doctest    to run all doctests embedded in the documentation (if enabled)"
+	@echo "  coverage   to run coverage check of the documentation (if enabled)"
+	@echo "  dummy      to check syntax errors of document sources"
+
+.PHONY: clean
+clean:
+	rm -rf $(BUILDDIR)/*
+
+.PHONY: html
+html:
+	$(SPHINXBUILD) -b html $(ALLSPHINXOPTS) $(BUILDDIR)/html
+	@echo
+	@echo "Build finished. The HTML pages are in $(BUILDDIR)/html."
+
+.PHONY: dirhtml
+dirhtml:
+	$(SPHINXBUILD) -b dirhtml $(ALLSPHINXOPTS) $(BUILDDIR)/dirhtml
+	@echo
+	@echo "Build finished. The HTML pages are in $(BUILDDIR)/dirhtml."
+
+.PHONY: singlehtml
+singlehtml:
+	$(SPHINXBUILD) -b singlehtml $(ALLSPHINXOPTS) $(BUILDDIR)/singlehtml
+	@echo
+	@echo "Build finished. The HTML page is in $(BUILDDIR)/singlehtml."
+
+.PHONY: pickle
+pickle:
+	$(SPHINXBUILD) -b pickle $(ALLSPHINXOPTS) $(BUILDDIR)/pickle
+	@echo
+	@echo "Build finished; now you can process the pickle files."
+
+.PHONY: json
+json:
+	$(SPHINXBUILD) -b json $(ALLSPHINXOPTS) $(BUILDDIR)/json
+	@echo
+	@echo "Build finished; now you can process the JSON files."
+
+.PHONY: htmlhelp
+htmlhelp:
+	$(SPHINXBUILD) -b htmlhelp $(ALLSPHINXOPTS) $(BUILDDIR)/htmlhelp
+	@echo
+	@echo "Build finished; now you can run HTML Help Workshop with the" \
+	      ".hhp project file in $(BUILDDIR)/htmlhelp."
+
+.PHONY: qthelp
+qthelp:
+	$(SPHINXBUILD) -b qthelp $(ALLSPHINXOPTS) $(BUILDDIR)/qthelp
+	@echo
+	@echo "Build finished; now you can run "qcollectiongenerator" with the" \
+	      ".qhcp project file in $(BUILDDIR)/qthelp, like this:"
+	@echo "# qcollectiongenerator $(BUILDDIR)/qthelp/pandas-gbq.qhcp"
+	@echo "To view the help file:"
+	@echo "# assistant -collectionFile $(BUILDDIR)/qthelp/pandas-gbq.qhc"
+
+.PHONY: applehelp
+applehelp:
+	$(SPHINXBUILD) -b applehelp $(ALLSPHINXOPTS) $(BUILDDIR)/applehelp
+	@echo
+	@echo "Build finished. The help book is in $(BUILDDIR)/applehelp."
+	@echo "N.B. You won't be able to view it unless you put it in" \
+	      "~/Library/Documentation/Help or install it in your application" \
+	      "bundle."
+
+.PHONY: devhelp
+devhelp:
+	$(SPHINXBUILD) -b devhelp $(ALLSPHINXOPTS) $(BUILDDIR)/devhelp
+	@echo
+	@echo "Build finished."
+	@echo "To view the help file:"
+	@echo "# mkdir -p $$HOME/.local/share/devhelp/pandas-gbq"
+	@echo "# ln -s $(BUILDDIR)/devhelp $$HOME/.local/share/devhelp/pandas-gbq"
+	@echo "# devhelp"
+
+.PHONY: epub
+epub:
+	$(SPHINXBUILD) -b epub $(ALLSPHINXOPTS) $(BUILDDIR)/epub
+	@echo
+	@echo "Build finished. The epub file is in $(BUILDDIR)/epub."
+
+.PHONY: epub3
+epub3:
+	$(SPHINXBUILD) -b epub3 $(ALLSPHINXOPTS) $(BUILDDIR)/epub3
+	@echo
+	@echo "Build finished. The epub3 file is in $(BUILDDIR)/epub3."
+
+.PHONY: latex
+latex:
+	$(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex
+	@echo
+	@echo "Build finished; the LaTeX files are in $(BUILDDIR)/latex."
+	@echo "Run \`make' in that directory to run these through (pdf)latex" \
+	      "(use \`make latexpdf' here to do that automatically)."
+
+.PHONY: latexpdf
+latexpdf:
+	$(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex
+	@echo "Running LaTeX files through pdflatex..."
+	$(MAKE) -C $(BUILDDIR)/latex all-pdf
+	@echo "pdflatex finished; the PDF files are in $(BUILDDIR)/latex."
+
+.PHONY: latexpdfja
+latexpdfja:
+	$(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex
+	@echo "Running LaTeX files through platex and dvipdfmx..."
+	$(MAKE) -C $(BUILDDIR)/latex all-pdf-ja
+	@echo "pdflatex finished; the PDF files are in $(BUILDDIR)/latex."
+
+.PHONY: text
+text:
+	$(SPHINXBUILD) -b text $(ALLSPHINXOPTS) $(BUILDDIR)/text
+	@echo
+	@echo "Build finished. The text files are in $(BUILDDIR)/text."
+
+.PHONY: man
+man:
+	$(SPHINXBUILD) -b man $(ALLSPHINXOPTS) $(BUILDDIR)/man
+	@echo
+	@echo "Build finished. The manual pages are in $(BUILDDIR)/man."
+
+.PHONY: texinfo
+texinfo:
+	$(SPHINXBUILD) -b texinfo $(ALLSPHINXOPTS) $(BUILDDIR)/texinfo
+	@echo
+	@echo "Build finished. The Texinfo files are in $(BUILDDIR)/texinfo."
+	@echo "Run \`make' in that directory to run these through makeinfo" \
+	      "(use \`make info' here to do that automatically)."
+
+.PHONY: info
+info:
+	$(SPHINXBUILD) -b texinfo $(ALLSPHINXOPTS) $(BUILDDIR)/texinfo
+	@echo "Running Texinfo files through makeinfo..."
+	make -C $(BUILDDIR)/texinfo info
+	@echo "makeinfo finished; the Info files are in $(BUILDDIR)/texinfo."
+
+.PHONY: gettext
+gettext:
+	$(SPHINXBUILD) -b gettext $(I18NSPHINXOPTS) $(BUILDDIR)/locale
+	@echo
+	@echo "Build finished. The message catalogs are in $(BUILDDIR)/locale."
+
+.PHONY: changes
+changes:
+	$(SPHINXBUILD) -b changes $(ALLSPHINXOPTS) $(BUILDDIR)/changes
+	@echo
+	@echo "The overview file is in $(BUILDDIR)/changes."
+
+.PHONY: linkcheck
+linkcheck:
+	$(SPHINXBUILD) -b linkcheck $(ALLSPHINXOPTS) $(BUILDDIR)/linkcheck
+	@echo
+	@echo "Link check complete; look for any errors in the above output " \
+	      "or in $(BUILDDIR)/linkcheck/output.txt."
+
+.PHONY: doctest
+doctest:
+	$(SPHINXBUILD) -b doctest $(ALLSPHINXOPTS) $(BUILDDIR)/doctest
+	@echo "Testing of doctests in the sources finished, look at the " \
+	      "results in $(BUILDDIR)/doctest/output.txt."
+
+.PHONY: coverage
+coverage:
+	$(SPHINXBUILD) -b coverage $(ALLSPHINXOPTS) $(BUILDDIR)/coverage
+	@echo "Testing of coverage in the sources finished, look at the " \
+	      "results in $(BUILDDIR)/coverage/python.txt."
+
+.PHONY: xml
+xml:
+	$(SPHINXBUILD) -b xml $(ALLSPHINXOPTS) $(BUILDDIR)/xml
+	@echo
+	@echo "Build finished. The XML files are in $(BUILDDIR)/xml."
+
+.PHONY: pseudoxml
+pseudoxml:
+	$(SPHINXBUILD) -b pseudoxml $(ALLSPHINXOPTS) $(BUILDDIR)/pseudoxml
+	@echo
+	@echo "Build finished. The pseudo-XML files are in $(BUILDDIR)/pseudoxml."
+
+.PHONY: dummy
+dummy:
+	$(SPHINXBUILD) -b dummy $(ALLSPHINXOPTS) $(BUILDDIR)/dummy
+	@echo
+	@echo "Build finished. Dummy builder generates no files."
diff --git a/packages/pandas-gbq/docs/_static/custom.css b/packages/pandas-gbq/docs/_static/custom.css
new file mode 100644
index 000000000000..b0a295464b23
--- /dev/null
+++ b/packages/pandas-gbq/docs/_static/custom.css
@@ -0,0 +1,20 @@
+div#python2-eol {
+	border-color: red;
+	border-width: medium;
+}
+
+/* Ensure minimum width for 'Parameters' / 'Returns' column */
+dl.field-list > dt {
+    min-width: 100px
+}
+
+/* Insert space between methods for readability */
+dl.method {
+	padding-top: 10px;
+	padding-bottom: 10px
+}
+
+/* Insert empty space between classes */
+dl.class {
+	padding-bottom: 50px
+}
diff --git a/packages/pandas-gbq/docs/_static/js/authcodescripts.js b/packages/pandas-gbq/docs/_static/js/authcodescripts.js
new file mode 100644
index 000000000000..1cf844b5061a
--- /dev/null
+++ b/packages/pandas-gbq/docs/_static/js/authcodescripts.js
@@ -0,0 +1,37 @@
+
+
+// Copyright (c) 2023 pandas-gbq Authors All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+
+function onloadoauthcode() {
+    const PARAMS = new Proxy(new URLSearchParams(window.location.search), {
+        get: (searchParams, prop) => searchParams.get(prop),
+    });
+    const AUTH_CODE = PARAMS.code;
+
+    document.querySelector('.auth-code').textContent = AUTH_CODE;
+
+    setupCopyButton(document.querySelector('.copy'), AUTH_CODE);
+}
+
+function setupCopyButton(button, text) {
+    button.addEventListener('click', () => {
+        navigator.clipboard.writeText(text);
+        button.textContent = "Verification Code Copied";
+        setTimeout(() => {
+            // Remove the aria-live label so that when the
+            // button text changes back to "Copy", it is
+            // not read out.
+            button.removeAttribute("aria-live");
+            button.textContent = "Copy";
+        }, 1000);
+
+        // Re-Add the aria-live attribute to enable speech for
+        // when button text changes next time.
+        setTimeout(() => {
+            button.setAttribute("aria-live", "assertive");
+        }, 2000);
+    });
+}
\ No newline at end of file
diff --git a/packages/pandas-gbq/docs/_static/style.css b/packages/pandas-gbq/docs/_static/style.css
new file mode 100644
index 000000000000..59a24072f882
--- /dev/null
+++ b/packages/pandas-gbq/docs/_static/style.css
@@ -0,0 +1,9 @@
+/**
+ * Copyright (c) 2017 pandas-gbq Authors All rights reserved.
+ * Use of this source code is governed by a BSD-style
+ * license that can be found in the LICENSE file.
+ */
+
+@import url("theme.css");
+
+a.internal em {font-style: normal}
diff --git a/packages/pandas-gbq/docs/_templates/layout.html b/packages/pandas-gbq/docs/_templates/layout.html
new file mode 100644
index 000000000000..6316a537f72b
--- /dev/null
+++ b/packages/pandas-gbq/docs/_templates/layout.html
@@ -0,0 +1,50 @@
+
+{% extends "!layout.html" %}
+{%- block content %}
+{%- if theme_fixed_sidebar|lower == 'true' %}
+  <div class="document">
+    {{ sidebar() }}
+    {%- block document %}
+      <div class="documentwrapper">
+      {%- if render_sidebar %}
+        <div class="bodywrapper">
+      {%- endif %}
+
+          {%- block relbar_top %}
+            {%- if theme_show_relbar_top|tobool %}
+              <div class="related top">
+                &nbsp;
+                {{- rellink_markup () }}
+              </div>
+            {%- endif %}
+          {% endblock %}
+
+          <div class="body" role="main">
+          	<div class="admonition" id="python2-eol"> 
+          	 As of January 1, 2020 this library no longer supports Python 2 on the latest released version. 
+          	 Library versions released prior to that date will continue to be available. For more information please
+          	 visit <a href="https://cloud.google.com/python/docs/python2-sunset/">Python 2 support on Google Cloud</a>.
+          	</div>
+            {% block body %} {% endblock %}
+          </div>
+
+          {%- block relbar_bottom %}
+            {%- if theme_show_relbar_bottom|tobool %}
+              <div class="related bottom">
+                &nbsp;
+                {{- rellink_markup () }}
+              </div>
+            {%- endif %}
+          {% endblock %}
+
+      {%- if render_sidebar %}
+        </div>
+      {%- endif %}
+      </div>
+    {%- endblock %}
+    <div class="clearer"></div>
+  </div>
+{%- else %}
+{{ super() }}
+{%- endif %}
+{%- endblock %}
diff --git a/packages/pandas-gbq/docs/api.rst b/packages/pandas-gbq/docs/api.rst
new file mode 100644
index 000000000000..d0b6622158cd
--- /dev/null
+++ b/packages/pandas-gbq/docs/api.rst
@@ -0,0 +1,27 @@
+.. currentmodule:: pandas_gbq
+.. _api:
+
+*************
+API Reference
+*************
+
+.. note::
+
+  Only functions and classes which are members of the ``pandas_gbq`` module
+  are considered public. Submodules and their members are considered private.
+
+.. autosummary::
+
+   read_gbq
+   to_gbq
+   context
+   Context
+
+.. autofunction:: read_gbq
+
+.. autofunction:: to_gbq
+
+.. autodata:: context
+
+.. autoclass:: Context
+   :members:
diff --git a/packages/pandas-gbq/docs/conf.py b/packages/pandas-gbq/docs/conf.py
new file mode 100644
index 000000000000..fbc405888214
--- /dev/null
+++ b/packages/pandas-gbq/docs/conf.py
@@ -0,0 +1,389 @@
+# -*- coding: utf-8 -*-
+# 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
+#
+# 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.
+#
+# pandas-gbq documentation build configuration file
+#
+# This file is execfile()d with the current directory set to its
+# containing dir.
+#
+# Note that not all possible configuration values are present in this
+# autogenerated file.
+#
+# All configuration values have a default; values that are commented out
+# serve to show the default.
+
+import os
+import shlex
+import sys
+
+# If extensions (or modules to document with autodoc) are in another directory,
+# add these directories to sys.path here. If the directory is relative to the
+# documentation root, use os.path.abspath to make it absolute, like shown here.
+sys.path.insert(0, os.path.abspath(".."))
+
+# For plugins that can not read conf.py.
+# See also: https://github.com/docascode/sphinx-docfx-yaml/issues/85
+sys.path.insert(0, os.path.abspath("."))
+
+__version__ = ""
+
+# -- General configuration ------------------------------------------------
+
+# If your documentation needs a minimal Sphinx version, state it here.
+needs_sphinx = "1.5.5"
+
+# Add any Sphinx extension module names here, as strings. They can be
+# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
+# ones.
+extensions = [
+    "sphinx.ext.autodoc",
+    "sphinx.ext.autosummary",
+    "sphinx.ext.intersphinx",
+    "sphinx.ext.coverage",
+    "sphinx.ext.doctest",
+    "sphinx.ext.napoleon",
+    "sphinx.ext.todo",
+    "sphinx.ext.viewcode",
+    "recommonmark",
+]
+
+# autodoc/autosummary flags
+autoclass_content = "both"
+autodoc_default_options = {"members": True}
+autosummary_generate = True
+
+
+# Add any paths that contain templates here, relative to this directory.
+templates_path = ["_templates"]
+
+# The suffix(es) of source filenames.
+# You can specify multiple suffix as a list of string:
+# source_suffix = ['.rst', '.md']
+source_suffix = [".rst", ".md"]
+
+# The encoding of source files.
+# source_encoding = 'utf-8-sig'
+
+# The root toctree document.
+root_doc = "index"
+
+# General information about the project.
+project = "pandas-gbq"
+copyright = "2019, Google"
+author = "Google APIs"
+
+# The version info for the project you're documenting, acts as replacement for
+# |version| and |release|, also used in various other places throughout the
+# built documents.
+#
+# The full version, including alpha/beta/rc tags.
+release = __version__
+# The short X.Y version.
+version = ".".join(release.split(".")[0:2])
+
+# The language for content autogenerated by Sphinx. Refer to documentation
+# for a list of supported languages.
+#
+# This is also used if you do content translation via gettext catalogs.
+# Usually you set "language" from the command line for these cases.
+language = None
+
+# There are two options for replacing |today|: either, you set today to some
+# non-false value, then it is used:
+# today = ''
+# Else, today_fmt is used as the format for a strftime call.
+# today_fmt = '%B %d, %Y'
+
+# List of patterns, relative to source directory, that match files and
+# directories to ignore when looking for source files.
+exclude_patterns = [
+    "_build",
+    "**/.nox/**/*",
+    "samples/AUTHORING_GUIDE.md",
+    "samples/CONTRIBUTING.md",
+    "samples/snippets/README.rst",
+]
+
+# The reST default role (used for this markup: `text`) to use for all
+# documents.
+# default_role = None
+
+# If true, '()' will be appended to :func: etc. cross-reference text.
+# add_function_parentheses = True
+
+# If true, the current module name will be prepended to all description
+# unit titles (such as .. function::).
+# add_module_names = True
+
+# If true, sectionauthor and moduleauthor directives will be shown in the
+# output. They are ignored by default.
+# show_authors = False
+
+# The name of the Pygments (syntax highlighting) style to use.
+pygments_style = "sphinx"
+
+# A list of ignored prefixes for module index sorting.
+# modindex_common_prefix = []
+
+# If true, keep warnings as "system message" paragraphs in the built documents.
+# keep_warnings = False
+
+# If true, `todo` and `todoList` produce output, else they produce nothing.
+todo_include_todos = True
+
+
+# -- Options for HTML output ----------------------------------------------
+
+# The theme to use for HTML and HTML Help pages.  See the documentation for
+# a list of builtin themes.
+html_theme = "alabaster"
+
+# Theme options are theme-specific and customize the look and feel of a theme
+# further.  For a list of options available for each theme, see the
+# documentation.
+html_theme_options = {
+    "description": "Google Cloud Client Libraries for pandas-gbq",
+    "github_user": "googleapis",
+    "github_repo": "python-bigquery-pandas",
+    "github_banner": True,
+    "font_family": "'Roboto', Georgia, sans",
+    "head_font_family": "'Roboto', Georgia, serif",
+    "code_font_family": "'Roboto Mono', 'Consolas', monospace",
+}
+
+# Add any paths that contain custom themes here, relative to this directory.
+# html_theme_path = []
+
+# The name for this set of Sphinx documents.  If None, it defaults to
+# "<project> v<release> documentation".
+# html_title = None
+
+# A shorter title for the navigation bar.  Default is the same as html_title.
+# html_short_title = None
+
+# The name of an image file (relative to this directory) to place at the top
+# of the sidebar.
+# html_logo = None
+
+# The name of an image file (within the static path) to use as favicon of the
+# docs.  This file should be a Windows icon file (.ico) being 16x16 or 32x32
+# pixels large.
+# html_favicon = None
+
+# Add any paths that contain custom static files (such as style sheets) here,
+# relative to this directory. They are copied after the builtin static files,
+# so a file named "default.css" will overwrite the builtin "default.css".
+html_static_path = ["_static"]
+
+# Add any extra paths that contain custom files (such as robots.txt or
+# .htaccess) here, relative to this directory. These files are copied
+# directly to the root of the documentation.
+# html_extra_path = []
+
+# If not '', a 'Last updated on:' timestamp is inserted at every page bottom,
+# using the given strftime format.
+# html_last_updated_fmt = '%b %d, %Y'
+
+# If true, SmartyPants will be used to convert quotes and dashes to
+# typographically correct entities.
+# html_use_smartypants = True
+
+# Custom sidebar templates, maps document names to template names.
+# html_sidebars = {}
+
+# Additional templates that should be rendered to pages, maps page names to
+# template names.
+# html_additional_pages = {}
+
+# If false, no module index is generated.
+# html_domain_indices = True
+
+# If false, no index is generated.
+# html_use_index = True
+
+# If true, the index is split into individual pages for each letter.
+# html_split_index = False
+
+# If true, links to the reST sources are added to the pages.
+# html_show_sourcelink = True
+
+# If true, "Created using Sphinx" is shown in the HTML footer. Default is True.
+# html_show_sphinx = True
+
+# If true, "(C) Copyright ..." is shown in the HTML footer. Default is True.
+# html_show_copyright = True
+
+# If true, an OpenSearch description file will be output, and all pages will
+# contain a <link> tag referring to it.  The value of this option must be the
+# base URL from which the finished HTML is served.
+# html_use_opensearch = ''
+
+# This is the file name suffix for HTML files (e.g. ".xhtml").
+# html_file_suffix = None
+
+# Language to be used for generating the HTML full-text search index.
+# Sphinx supports the following languages:
+#   'da', 'de', 'en', 'es', 'fi', 'fr', 'hu', 'it', 'ja'
+#   'nl', 'no', 'pt', 'ro', 'ru', 'sv', 'tr'
+# html_search_language = 'en'
+
+# A dictionary with options for the search language support, empty by default.
+# Now only 'ja' uses this config value
+# html_search_options = {'type': 'default'}
+
+# The name of a javascript file (relative to the configuration directory) that
+# implements a search results scorer. If empty, the default will be used.
+# html_search_scorer = 'scorer.js'
+
+# Output file base name for HTML help builder.
+htmlhelp_basename = "pandas-gbq-doc"
+
+# -- Options for warnings ------------------------------------------------------
+
+
+suppress_warnings = [
+    # Temporarily suppress this to avoid "more than one target found for
+    # cross-reference" warning, which are intractable for us to avoid while in
+    # a mono-repo.
+    # See https://github.com/sphinx-doc/sphinx/blob
+    # /2a65ffeef5c107c19084fabdd706cdff3f52d93c/sphinx/domains/python.py#L843
+    "ref.python"
+]
+
+# -- Options for LaTeX output ---------------------------------------------
+
+latex_elements = {
+    # The paper size ('letterpaper' or 'a4paper').
+    #'papersize': 'letterpaper',
+    # The font size ('10pt', '11pt' or '12pt').
+    #'pointsize': '10pt',
+    # Additional stuff for the LaTeX preamble.
+    #'preamble': '',
+    # Latex figure (float) alignment
+    #'figure_align': 'htbp',
+}
+
+# Grouping the document tree into LaTeX files. List of tuples
+# (source start file, target name, title,
+#  author, documentclass [howto, manual, or own class]).
+latex_documents = [
+    (
+        root_doc,
+        "pandas-gbq.tex",
+        "pandas-gbq Documentation",
+        author,
+        "manual",
+    )
+]
+
+# The name of an image file (relative to this directory) to place at the top of
+# the title page.
+# latex_logo = None
+
+# For "manual" documents, if this is true, then toplevel headings are parts,
+# not chapters.
+# latex_use_parts = False
+
+# If true, show page references after internal links.
+# latex_show_pagerefs = False
+
+# If true, show URL addresses after external links.
+# latex_show_urls = False
+
+# Documents to append as an appendix to all manuals.
+# latex_appendices = []
+
+# If false, no module index is generated.
+# latex_domain_indices = True
+
+
+# -- Options for manual page output ---------------------------------------
+
+# One entry per manual page. List of tuples
+# (source start file, name, description, authors, manual section).
+man_pages = [
+    (
+        root_doc,
+        "pandas-gbq",
+        "pandas-gbq Documentation",
+        [author],
+        1,
+    )
+]
+
+# If true, show URL addresses after external links.
+# man_show_urls = False
+
+
+# -- Options for Texinfo output -------------------------------------------
+
+# Grouping the document tree into Texinfo files. List of tuples
+# (source start file, target name, title, author,
+#  dir menu entry, description, category)
+texinfo_documents = [
+    (
+        root_doc,
+        "pandas-gbq",
+        "pandas-gbq Documentation",
+        author,
+        "pandas-gbq",
+        "pandas-gbq Library",
+        "APIs",
+    )
+]
+
+# Documents to append as an appendix to all manuals.
+# texinfo_appendices = []
+
+# If false, no module index is generated.
+# texinfo_domain_indices = True
+
+# How to display URL addresses: 'footnote', 'no', or 'inline'.
+# texinfo_show_urls = 'footnote'
+
+# If true, do not generate a @detailmenu in the "Top" node's menu.
+# texinfo_no_detailmenu = False
+
+
+# Example configuration for intersphinx: refer to the Python standard library.
+intersphinx_mapping = {
+    "python": ("https://python.readthedocs.org/en/latest/", None),
+    "google-auth": ("https://googleapis.dev/python/google-auth/latest/", None),
+    "google.api_core": (
+        "https://googleapis.dev/python/google-api-core/latest/",
+        None,
+    ),
+    "grpc": ("https://grpc.github.io/grpc/python/", None),
+    "proto-plus": ("https://proto-plus-python.readthedocs.io/en/latest/", None),
+    "protobuf": ("https://googleapis.dev/python/protobuf/latest/", None),
+    "pandas": ("https://pandas.pydata.org/pandas-docs/stable/", None),
+    "pydata-google-auth": (
+        "https://pydata-google-auth.readthedocs.io/en/latest/",
+        None,
+    ),
+}
+
+
+# Napoleon settings
+napoleon_google_docstring = True
+napoleon_numpy_docstring = True
+napoleon_include_private_with_doc = False
+napoleon_include_special_with_doc = True
+napoleon_use_admonition_for_examples = False
+napoleon_use_admonition_for_notes = False
+napoleon_use_admonition_for_references = False
+napoleon_use_ivar = False
+napoleon_use_param = True
+napoleon_use_rtype = True
diff --git a/packages/pandas-gbq/docs/contributing.rst b/packages/pandas-gbq/docs/contributing.rst
new file mode 100644
index 000000000000..39c2694a623b
--- /dev/null
+++ b/packages/pandas-gbq/docs/contributing.rst
@@ -0,0 +1,489 @@
+.. _contributing:
+
+**************************
+Contributing to pandas-gbq
+**************************
+
+.. contents:: Table of contents:
+   :local:
+
+Where to start?
+===============
+
+All contributions, bug reports, bug fixes, documentation improvements,
+enhancements and ideas are welcome.
+
+If you are simply looking to start working with the *pandas-gbq* codebase, navigate to the
+`GitHub "issues" tab <https://github.com/googleapis/python-bigquery-pandas/issues>`_ and start looking through
+interesting issues.
+
+Or maybe through using *pandas-gbq* you have an idea of your own or are looking for something
+in the documentation and thinking 'this can be improved'...you can do something about it!
+
+Feel free to ask questions on the `mailing list
+<https://groups.google.com/forum/?fromgroups#!forum/pydata>`_.
+
+Bug reports and enhancement requests
+====================================
+
+Bug reports are an important part of making *pandas-gbq* more stable.  Having a complete bug report
+will allow others to reproduce the bug and provide insight into fixing it.  Because many versions of
+*pandas-gbq* are supported, knowing version information will also identify improvements made since
+previous versions. Trying the bug-producing code out on the *master* branch is often a worthwhile exercise
+to confirm the bug still exists.  It is also worth searching existing bug reports and pull requests
+to see if the issue has already been reported and/or fixed.
+
+Bug reports must:
+
+#. Include a short, self-contained Python snippet reproducing the problem.
+   You can format the code nicely by using `GitHub Flavored Markdown
+   <http://github.github.com/github-flavored-markdown/>`__
+
+   .. code-block:: python
+
+      >>> from pandas_gbq import gbq
+      >>> df = gbq.read_gbq(...)
+      ...
+
+#. Include the full version string of *pandas-gbq*.
+
+   .. code-block:: python
+
+      >>> import pandas_gbq
+      >>> pandas_gbq.__version__
+      ...
+
+#. Explain why the current behavior is wrong/not desired and what you expect instead.
+
+The issue will then show up to the *pandas-gbq* community and be open to comments/ideas from others.
+
+Working with the code
+=====================
+
+Now that you have an issue you want to fix, enhancement to add, or documentation to improve,
+you need to learn how to work with GitHub and the *pandas-gbq* code base.
+
+Version control, Git, and GitHub
+--------------------------------
+
+To the new user, working with Git is one of the more daunting aspects of contributing to *pandas-gbq*.
+It can very quickly become overwhelming, but sticking to the guidelines below will help keep the process
+straightforward and mostly trouble free.  As always, if you are having difficulties please
+feel free to ask for help.
+
+The code is hosted on `GitHub <https://www.github.com/googleapis/python-bigquery-pandas>`_. To
+contribute you will need to sign up for a `free GitHub account
+<https://github.com/signup/free>`_. We use `Git <http://git-scm.com/>`_ for
+version control to allow many people to work together on the project.
+
+Some great resources for learning Git:
+
+* the `GitHub help pages <http://help.github.com/>`_.
+* the `NumPy's documentation <http://docs.scipy.org/doc/numpy/dev/index.html>`_.
+* Matthew Brett's `Pydagogue <http://matthew-brett.github.com/pydagogue/>`_.
+
+Getting started with Git
+------------------------
+
+`GitHub has instructions <http://help.github.com/set-up-git-redirect>`__ for installing git,
+setting up your SSH key, and configuring git.  All these steps need to be completed before
+you can work seamlessly between your local repository and GitHub.
+
+.. _contributing.forking:
+
+Forking
+-------
+
+You will need your own fork to work on the code. Go to the `pandas-gbq project
+page <https://github.com/googleapis/python-bigquery-pandas>`_ and hit the ``Fork`` button. You will
+want to clone your fork to your machine::
+
+    git clone git@github.com:your-user-name/pandas-gbq.git pandas-gbq-yourname
+    cd pandas-gbq-yourname
+    git remote add upstream git://github.com/googleapis/python-bigquery-pandas.git
+
+This creates the directory `pandas-gbq-yourname` and connects your repository to
+the upstream (main project) *pandas-gbq* repository.
+
+The testing suite will run automatically on CircleCI once your pull request is submitted.
+However, if you wish to run the test suite on a branch prior to submitting the pull request,
+then CircleCI needs to be hooked up to your GitHub repository.  Instructions for doing so
+are `here <https://circleci.com/docs/2.0/getting-started/>`__.
+
+Creating a branch
+-----------------
+
+You want your master branch to reflect only production-ready code, so create a
+feature branch for making your changes. For example::
+
+    git branch shiny-new-feature
+    git checkout shiny-new-feature
+
+The above can be simplified to::
+
+    git checkout -b shiny-new-feature
+
+This changes your working directory to the shiny-new-feature branch.  Keep any
+changes in this branch specific to one bug or feature so it is clear
+what the branch brings to *pandas-gbq*. You can have many shiny-new-features
+and switch in between them using the git checkout command.
+
+To update this branch, you need to retrieve the changes from the master branch::
+
+    git fetch upstream
+    git rebase upstream/master
+
+This will replay your commits on top of the latest pandas-gbq git master.  If this
+leads to merge conflicts, you must resolve these before submitting your pull
+request.  If you have uncommitted changes, you will need to ``stash`` them prior
+to updating.  This will effectively store your changes and they can be reapplied
+after updating.
+
+Install in Development Mode
+---------------------------
+
+It's helpful to install pandas-gbq in development mode so that you can
+use the library without reinstalling the package after every change.
+
+Pip & virtualenv
+~~~~~~~~~~~~~~~~
+
+Create a new `virtual
+environment <https://virtualenv.pypa.io/en/stable/userguide/>`__.
+
+.. code-block:: shell
+
+    $ virtualenv env
+    $ source env/bin/activate
+
+You can install pandas-gbq and its dependencies in `development mode via
+pip <https://pip.pypa.io/en/stable/reference/pip_install/#editable-installs>`__.
+
+.. code-block:: shell
+
+    $ pip install -e .
+
+Contributing to the code base
+=============================
+
+.. contents:: Code Base:
+   :local:
+
+Code standards
+--------------
+
+Writing good code is not just about what you write. It is also about *how* you
+write it. During testing on Travis-CI, several tools will be run to check your
+code for stylistic errors. Generating any warnings will cause the test to fail.
+Thus, good style is a requirement for submitting code to *pandas-gbq*.
+
+In addition, because a lot of people use our library, it is important that we
+do not make sudden changes to the code that could have the potential to break
+a lot of user code as a result, that is, we need it to be as *backwards compatible*
+as possible to avoid mass breakages.
+
+Python (PEP8)
+~~~~~~~~~~~~~
+
+*pandas-gbq* uses the `PEP8 <http://www.python.org/dev/peps/pep-0008/>`_ standard.
+There are several tools to ensure you abide by this standard. Here are *some* of
+the more common ``PEP8`` issues:
+
+  - we restrict line-length to 79 characters to promote readability
+  - passing arguments should have spaces after commas, e.g. ``foo(arg1, arg2, kw1='bar')``
+
+CircleCI will run the `'black' code formatting tool
+<https://black.readthedocs.io/>`_ and report any stylistic errors in your
+code. Therefore, it is helpful before submitting code to run the formatter
+yourself::
+
+    pip install black
+    black .
+
+Backwards Compatibility
+~~~~~~~~~~~~~~~~~~~~~~~
+
+Please try to maintain backward compatibility. If you think breakage is required,
+clearly state why as part of the pull request.  Also, be careful when changing method
+signatures and add deprecation warnings where needed.
+
+Test-driven development/code writing
+------------------------------------
+
+*pandas-gbq* is serious about testing and strongly encourages contributors to embrace
+`test-driven development (TDD) <http://en.wikipedia.org/wiki/Test-driven_development>`_.
+This development process "relies on the repetition of a very short development cycle:
+first the developer writes an (initially failing) automated test case that defines a desired
+improvement or new function, then produces the minimum amount of code to pass that test."
+So, before actually writing any code, you should write your tests.  Often the test can be
+taken from the original GitHub issue.  However, it is always worth considering additional
+use cases and writing corresponding tests.
+
+Adding tests is one of the most common requests after code is pushed to *pandas-gbq*.  Therefore,
+it is worth getting in the habit of writing tests ahead of time so this is never an issue.
+
+Like many packages, *pandas-gbq* uses `pytest <http://doc.pytest.org/en/latest/>`_.
+
+Running the test suite
+~~~~~~~~~~~~~~~~~~~~~~
+
+The tests can then be run directly inside your Git clone (without having to
+install *pandas-gbq*) by typing::
+
+    pytest tests/unit
+    pytest tests/system.py
+
+The tests suite is exhaustive and takes around 20 minutes to run.  Often it is
+worth running only a subset of tests first around your changes before running the
+entire suite.
+
+The easiest way to do this is with::
+
+    pytest tests/path/to/test.py -k regex_matching_test_name
+
+Or with one of the following constructs::
+
+    pytest tests/[test-module].py
+    pytest tests/[test-module].py::[TestClass]
+    pytest tests/[test-module].py::[TestClass]::[test_method]
+
+For more, see the `pytest <http://doc.pytest.org/en/latest/>`_ documentation.
+
+Testing on multiple Python versions
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+pandas-gbq uses `nox <https://nox.readthedocs.io>`__ to automate testing in
+multiple Python environments. First, install nox.
+
+.. code-block:: shell
+
+    $ pip install --upgrade nox-automation
+
+To run tests in all versions of Python, run `nox` from the repository's root
+directory.
+
+.. _contributing.gbq_integration_tests:
+
+Running Google BigQuery Integration Tests
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+You will need to create a Google BigQuery private key in JSON format in order
+to run Google BigQuery integration tests on your local machine and on
+CircleCI. The first step is to create a `service account
+<https://console.cloud.google.com/iam-admin/serviceaccounts/>`__. Grant the
+service account permissions to run BigQuery queries and to create datasets
+and tables.
+
+To run the integration tests locally, set the following environment variables
+before running ``pytest``:
+
+#. ``GBQ_PROJECT_ID`` with the value being the ID of your BigQuery project.
+#. ``GBQ_GOOGLE_APPLICATION_CREDENTIALS`` with the value being the *path* to
+   the JSON key that you downloaded for your service account.
+
+Integration tests are skipped in pull requests because the credentials that
+are required for running Google BigQuery integration tests are
+`configured in the CircleCI web interface
+<https://circleci.com/docs/2.0/env-vars/#setting-an-environment-variable-in-a-project>`_
+and are only accessible from the googleapis/python-bigquery-pandas repository. The
+credentials won't be available on forks of pandas-gbq. Here are the steps to
+run gbq integration tests on a forked repository:
+
+#. Go to `CircleCI <https://circleci.com/dashboard>`__ and sign in with your
+   GitHub account.
+#. Switch to your personal account in the top-left organization switcher.
+#. Use the "Add projects" tab to enable CircleCI for your fork.
+#. Click on the gear icon to edit your CircleCI build, and add two environment
+   variables:
+
+   - ``GBQ_PROJECT_ID`` with the value being the ID of your BigQuery project.
+
+   - ``SERVICE_ACCOUNT_KEY`` with the value being the base64-encoded
+     *contents* of the JSON key that you downloaded for your service account.
+
+   Keep the contents of these variables confidential. These variables contain
+   sensitive data and you do not want their contents being exposed in build
+   logs.
+#. Your branch should be tested automatically once it is pushed. You can check
+   the status by visiting your Circle CI branches page which exists at the
+   following location: https://circleci.com/gh/your-username/python-bigquery-pandas.
+   Click on a build job for your branch.
+
+Documenting your code
+---------------------
+
+Changes should follow convential commits.  The release-please bot uses the
+commit message to create an ongoing change log.
+
+If your code is an enhancement, it is most likely necessary to add usage
+examples to the existing documentation. Further, to let users know when
+this feature was added, the ``versionadded`` directive is used. The sphinx
+syntax for that is:
+
+.. code-block:: rst
+
+  .. versionadded:: 0.1.3
+
+This will put the text *New in version 0.1.3* wherever you put the sphinx
+directive. This should also be put in the docstring when adding a new function
+or method.
+
+Contributing your changes to *pandas-gbq*
+=========================================
+
+Committing your code
+--------------------
+
+Keep style fixes to a separate commit to make your pull request more readable.
+
+Once you've made changes, you can see them by typing::
+
+    git status
+
+If you have created a new file, it is not being tracked by git. Add it by typing::
+
+    git add path/to/file-to-be-added.py
+
+Doing 'git status' again should give something like::
+
+    # On branch shiny-new-feature
+    #
+    #       modified:   /relative/path/to/file-you-added.py
+    #
+
+Finally, commit your changes to your local repository with an explanatory message.  *pandas-gbq*
+uses `conventional commit message prefixes
+<https://www.conventionalcommits.org/en/v1.0.0/>`_ and layout.  Here are some
+common prefixes along with general guidelines for when to use them:
+
+    * feat: Enhancement, new functionality
+    * fix: Bug fix, performance improvement
+    * doc: Additions/updates to documentation
+    * deps: Change to package dependencies
+    * test: Additions/updates to tests
+    * chore: Updates to the build process/scripts
+    * refactor: Code cleanup
+
+The following defines how a commit message should be structured.  Please reference the
+relevant GitHub issues in your commit message using GH1234 or #1234.  Either style
+is fine, but the former is generally preferred:
+
+    * a subject line with `< 80` chars.
+    * One blank line.
+    * Optionally, a commit message body.
+
+Now you can commit your changes in your local repository::
+
+    git commit -m
+
+Combining commits
+-----------------
+
+If you have multiple commits, you may want to combine them into one commit, often
+referred to as "squashing" or "rebasing".  This is a common request by package maintainers
+when submitting a pull request as it maintains a more compact commit history.  To rebase
+your commits::
+
+    git rebase -i HEAD~#
+
+Where # is the number of commits you want to combine.  Then you can pick the relevant
+commit message and discard others.
+
+To squash to the master branch do::
+
+    git rebase -i master
+
+Use the ``s`` option on a commit to ``squash``, meaning to keep the commit messages,
+or ``f`` to ``fixup``, meaning to merge the commit messages.
+
+Then you will need to push the branch (see below) forcefully to replace the current
+commits with the new ones::
+
+    git push origin shiny-new-feature -f
+
+
+Pushing your changes
+--------------------
+
+When you want your changes to appear publicly on your GitHub page, push your
+forked feature branch's commits::
+
+    git push origin shiny-new-feature
+
+Here ``origin`` is the default name given to your remote repository on GitHub.
+You can see the remote repositories::
+
+    git remote -v
+
+If you added the upstream repository as described above you will see something
+like::
+
+    origin  git@github.com:yourname/pandas-gbq.git (fetch)
+    origin  git@github.com:yourname/pandas-gbq.git (push)
+    upstream        git://github.com/googleapis/python-bigquery-pandas.git (fetch)
+    upstream        git://github.com/googleapis/python-bigquery-pandas.git (push)
+
+Now your code is on GitHub, but it is not yet a part of the *pandas-gbq* project.  For that to
+happen, a pull request needs to be submitted on GitHub.
+
+Review your code
+----------------
+
+When you're ready to ask for a code review, file a pull request. Before you do, once
+again make sure that you have followed all the guidelines outlined in this document
+regarding code style, tests, performance tests, and documentation. You should also
+double check your branch changes against the branch it was based on:
+
+#. Navigate to your repository on GitHub -- https://github.com/your-user-name/pandas-gbq
+#. Click on ``Branches``
+#. Click on the ``Compare`` button for your feature branch
+#. Select the ``base`` and ``compare`` branches, if necessary. This will be ``master`` and
+   ``shiny-new-feature``, respectively.
+
+Finally, make the pull request
+------------------------------
+
+If everything looks good, you are ready to make a pull request.  A pull request is how
+code from a local repository becomes available to the GitHub community and can be looked
+at and eventually merged into the master version.  This pull request and its associated
+changes will eventually be committed to the master branch and available in the next
+release.  To submit a pull request:
+
+#. Navigate to your repository on GitHub
+#. Click on the ``Pull Request`` button
+#. You can then click on ``Commits`` and ``Files Changed`` to make sure everything looks
+   okay one last time
+#. Write a description of your changes in the ``Preview Discussion`` tab
+#. Click ``Send Pull Request``.
+
+This request then goes to the repository maintainers, and they will review
+the code. If you need to make more changes, you can make them in
+your branch, push them to GitHub, and the pull request will be automatically
+updated.  Pushing them to GitHub again is done by::
+
+    git push -f origin shiny-new-feature
+
+This will automatically update your pull request with the latest code and restart the
+Travis-CI tests.
+
+Delete your merged branch (optional)
+------------------------------------
+
+Once your feature branch is accepted into upstream, you'll probably want to get rid of
+the branch. First, merge upstream master into your branch so git knows it is safe to
+delete your branch::
+
+    git fetch upstream
+    git checkout master
+    git merge upstream/master
+
+Then you can just do::
+
+    git branch -d shiny-new-feature
+
+Make sure you use a lower-case ``-d``, or else git won't warn you if your feature
+branch has not actually been merged.
+
+The branch will still exist on GitHub, so to delete it there do::
+
+    git push origin --delete shiny-new-feature
diff --git a/packages/pandas-gbq/docs/howto/authentication.rst b/packages/pandas-gbq/docs/howto/authentication.rst
new file mode 100644
index 000000000000..2af4801ff117
--- /dev/null
+++ b/packages/pandas-gbq/docs/howto/authentication.rst
@@ -0,0 +1,241 @@
+Authentication
+==============
+
+.. contents:: Table of Contents
+    :local:
+    :depth: 1
+
+Before you begin, you must create a Google Cloud Platform project. Use the
+`BigQuery sandbox <https://cloud.google.com/bigquery/docs/sandbox>`__ to try
+the service for free.
+
+pandas-gbq `authenticates with the Google BigQuery service
+<https://cloud.google.com/bigquery/docs/authentication>`_ via OAuth 2.0. Use
+the ``credentials`` argument to explicitly pass in Google
+:class:`~google.auth.credentials.Credentials`.
+
+.. _authentication:
+
+Default Authentication Methods
+------------------------------
+
+If the ``credentials`` parameter is not set, pandas-gbq tries the following
+authentication methods:
+
+1. In-memory, cached credentials at ``pandas_gbq.context.credentials``. See
+   :attr:`pandas_gbq.Context.credentials` for details.
+
+   .. code:: python
+
+       import pandas_gbq
+
+       credentials = ...  # From google-auth or pydata-google-auth library.
+
+       # Update the in-memory credentials cache (added in pandas-gbq 0.7.0).
+       pandas_gbq.context.credentials = credentials
+       pandas_gbq.context.project = "your-project-id"
+
+       # The credentials and project_id arguments can be omitted.
+       df = pandas_gbq.read_gbq("SELECT my_col FROM `my_dataset.my_table`")
+
+2. If running on `Google Colab <https://colab.research.google.com/>`_,
+   pandas-gbq attempts to authenticate with the
+   ``google.colab.auth.authenticate_user()`` method. See the `Getting started
+   with BigQuery on Colab notebook
+   <https://colab.research.google.com/notebooks/bigquery.ipynb>`_ for an
+   example of using this authentication method with other libraries that use
+   Google BigQuery.
+
+   .. note::
+
+      To use Colab authentication, install version 1.8.0 or later of the
+      ``pydata-google-auth`` package.
+
+3. Application Default Credentials via the :func:`google.auth.default`
+   function.
+
+   .. note::
+
+       If pandas-gbq can obtain default credentials but those credentials
+       cannot be used to query BigQuery, pandas-gbq will also try obtaining
+       user account credentials.
+
+       A common problem with default credentials when running on Google
+       Compute Engine is that the VM does not have sufficient `access scopes
+       <https://cloud.google.com/compute/docs/access/service-accounts#accesscopesiam>`_
+       to query BigQuery.
+
+4. User account credentials.
+
+   pandas-gbq loads cached credentials from a hidden user folder on the
+   operating system.
+
+   Windows
+       ``%APPDATA%\pandas_gbq\bigquery_credentials.dat``
+
+   Linux/Mac/Unix
+       ``~/.config/pandas_gbq/bigquery_credentials.dat``
+
+   If pandas-gbq does not find cached credentials, it prompts you to open a
+   web browser, where you can grant pandas-gbq permissions to access your
+   cloud resources. These credentials are only used locally. See the
+   :doc:`privacy policy <../privacy>` for details.
+
+
+Authenticating with a Service Account
+--------------------------------------
+
+Using service account credentials is particularly useful when working on
+remote servers without access to user input.
+
+Create a service account key via the `service account key creation page
+<https://console.cloud.google.com/apis/credentials/serviceaccountkey>`_ in
+the Google Cloud Platform Console. Select the JSON key type and download the
+key file.
+
+To use service account credentials, set the ``credentials`` parameter to the result of a call to:
+
+* :func:`google.oauth2.service_account.Credentials.from_service_account_file`,
+    which accepts a file path to the JSON file.
+
+    .. code:: python
+
+        from google.oauth2 import service_account
+        import pandas_gbq
+
+        credentials = service_account.Credentials.from_service_account_file(
+            'path/to/key.json',
+        )
+        df = pandas_gbq.read_gbq(sql, project_id="YOUR-PROJECT-ID", credentials=credentials)
+
+* :func:`google.oauth2.service_account.Credentials.from_service_account_info`,
+    which accepts a dictionary corresponding to the JSON file contents.
+
+    .. code:: python
+
+        from google.oauth2 import service_account
+        import pandas_gbq
+
+        credentials = service_account.Credentials.from_service_account_info(
+            {
+                "type": "service_account",
+                "project_id": "YOUR-PROJECT-ID",
+                "private_key_id": "6747200734a1f2b9d8d62fc0b9414c5f2461db0e",
+                "private_key": "-----BEGIN PRIVATE KEY-----\nM...I==\n-----END PRIVATE KEY-----\n",
+                "client_email": "service-account@YOUR-PROJECT-ID.iam.gserviceaccount.com",
+                "client_id": "12345678900001",
+                "auth_uri": "https://accounts.google.com/o/oauth2/auth",
+                "token_uri": "https://accounts.google.com/o/oauth2/token",
+                "auth_provider_x509_cert_url": "https://www.googleapis.com/oauth2/v1/certs",
+                "client_x509_cert_url": "https://www.googleapis.com/...iam.gserviceaccount.com"
+            },
+        )
+        df = pandas_gbq.read_gbq(sql, project_id="YOUR-PROJECT-ID", credentials=credentials)
+
+Alternatively, you can set ``GOOGLE_APPLICATION_CREDENTIALS`` environment variable to the
+full path to the JSON file.
+
+.. code-block:: shell
+
+   $ export GOOGLE_APPLICATION_CREDENTIALS=/path/to/key.json
+
+Use the :func:`~google.oauth2.service_account.Credentials.with_scopes` method
+to use authorize with specific OAuth2 scopes, which may be required in
+queries to federated data sources such as Google Sheets.
+
+.. code:: python
+
+   credentials = ...
+   credentials = credentials.with_scopes(
+       [
+           'https://www.googleapis.com/auth/drive',
+           'https://www.googleapis.com/auth/cloud-platform',
+       ],
+   )
+   df = pandas_gbq.read_gbq(..., credentials=credentials)
+
+See the `Getting started with authentication on Google Cloud Platform
+<https://cloud.google.com/docs/authentication/getting-started>`_ guide and
+`Google Auth Library User Guide
+<https://google-auth.readthedocs.io/en/latest/user-guide.html>`_ for more information
+on service accounts.
+
+.. _authentication-user:
+
+Authenticating with a User Account
+----------------------------------
+
+Use the `pydata-google-auth <https://pydata-google-auth.readthedocs.io/>`__
+library to authenticate with a user account (i.e. a G Suite or Gmail
+account). The :func:`pydata_google_auth.get_user_credentials` function loads
+credentials from a cache on disk or initiates an OAuth 2.0 flow if cached
+credentials are not found.
+
+.. code:: python
+
+   import pandas_gbq
+   import pydata_google_auth
+
+   SCOPES = [
+       'https://www.googleapis.com/auth/cloud-platform',
+       'https://www.googleapis.com/auth/drive',
+   ]
+
+   credentials = pydata_google_auth.get_user_credentials(
+       SCOPES,
+       # Note, this doesn't work if you're running from a notebook on a
+       # remote sever, such as over SSH or with Google Colab. In those cases,
+       # install the gcloud command line interface and authenticate with the
+       # `gcloud auth application-default login` command and the `--no-browser`
+       # option.
+       auth_local_webserver=True,
+   )
+
+   df = pandas_gbq.read_gbq(
+       "SELECT my_col FROM `my_dataset.my_table`",
+       project_id='YOUR-PROJECT-ID',
+       credentials=credentials,
+   )
+
+.. warning::
+
+   Do not store credentials on disk when using shared computing resources
+   such as a GCE VM or Colab notebook. Use the
+   :data:`pydata_google_auth.cache.NOOP` cache to avoid writing credentials
+   to disk.
+
+   .. code:: python
+
+      import pydata_google_auth.cache
+
+      credentials = pydata_google_auth.get_user_credentials(
+          SCOPES,
+          # Use the NOOP cache to avoid writing credentials to disk.
+          cache=pydata_google_auth.cache.NOOP,
+      )
+
+Additional information on the user credentials authentication mechanism
+can be found in the `Google Cloud authentication guide
+<https://cloud.google.com/docs/authentication/end-user>`__.
+
+Authenticating from Highly Constrained Development Environments
+---------------------------------------------------------------
+
+The instructions above may not be adequate for users who are working in
+a *highly constrained development environment*:
+
+Highly constrained development environments typically prevent users from using
+the `Default Authentication Methods` and are generally characterized by one or
+more of the following circumstances:
+
+* There are limitations on what you can install on the development environment
+  (i.e. you can't install ``gcloud``).
+* You don't have access to a graphical user interface (i.e. you are remotely
+  SSH'ed into a headless server and don't have access to a browser to complete
+  the authentication process used in the default login workflow) .
+* The code is being executed in a typical data science context: using a Jupyter
+  (or similar) notebook.
+
+If the conditions above apply to you, your needs may be better served
+by the content in the `Authentication (Highly Constrained Development Environment)
+<authentication_highly_constrained_environments.html>`_ section.
diff --git a/packages/pandas-gbq/docs/howto/authentication_highly_constrained_environments.rst b/packages/pandas-gbq/docs/howto/authentication_highly_constrained_environments.rst
new file mode 100644
index 000000000000..a8c100d8de97
--- /dev/null
+++ b/packages/pandas-gbq/docs/howto/authentication_highly_constrained_environments.rst
@@ -0,0 +1,301 @@
+:orphan:
+
+Authentication (Highly Constrained Development Environments)
+============================================================
+
+Before you begin, you must create a Google Cloud Platform project. Use the
+`BigQuery sandbox <https://cloud.google.com/bigquery/docs/sandbox>`__ to try
+the service for free.
+
+pandas-gbq `authenticates with the Google BigQuery service
+<https://cloud.google.com/bigquery/docs/authentication/>`_ via OAuth 2.0. Use
+the ``credentials`` argument to explicitly pass in Google
+:class:`~google.auth.credentials.Credentials`.
+
+.. _authentication_hce:
+
+
+Authenticating from Highly Constrained Development Environments
+---------------------------------------------------------------
+
+These instructions are primarily for users who are working in a *highly
+constrained development environment*. 
+
+Highly constrained development environments typically prevent users from using
+the `Default Authentication Methods` and are generally characterized by one or
+more of the following circumstances:
+
+* There are limitations on what you can install on the development environment
+  (i.e. you can't install ``gcloud``).
+* You don't have access to a graphical user interface (i.e. you are remotely
+  SSH'ed into a headless server and don't have access to a browser to complete
+  the authentication process used in the default login workflow) .
+* The code is being executed in a typical data science context: using a Jupyter
+  (or similar) notebook.
+
+If the conditions above **do not** apply to you, your needs may be better served
+by the content in the `Default Authentication Methods <authentication.html>`_ section.
+
+When dealing with highly constrained environments, there are two primary options
+that one can choose from: Testing Mode OR an institution-specific authentication
+page.
+
+#. Testing Mode: This approach requires that you enable Testing Mode on your
+   Cloud Project and that you have fewer than 100 users.
+#. Institution-specific authentication page: In cases where the Testing Mode
+   option is not possible and/or there are specific institutional needs,
+   you/your institution can create and host an institution-specific OAuth
+   authentication page and associate a redirect URI to that Cloud Project.
+
+OPTION 1 - Testing Mode
+^^^^^^^^^^^^^^^^^^^^^^^
+
+This approach is for limited use, such as when testing your product. It is not
+intended for production use. If you have fewer than 100 users, it is possible to
+configure User Type as External and the Publishing Status of your Project as
+Testing Mode to enable OAuth Out-of-Band (OOB) Authentication. NOTE: general
+purpose `OOB Authentication was deprecated <https://developers.googleblog.com/2022/02/making-oauth-flows-safer.html>`_ for all use cases except Testing Mode.
+
+.. note:: Projects configured with a Publishing Status of Testing are **limited to
+   up to 100 test users** who must be individually listed in the OAuth consent
+   screen. A test user consumes a Project's test user quota once added to the
+   Project.
+
+   Authentications by a test user **will expire seven days from the time of consent.** If your OAuth client requests an offline access type and receives a refresh token, that token will also expire.
+
+   To move a project from Testing Mode to In Production requires app verification
+   and requires your institution to switch to using an alternate authentication
+   method, such as an institution-specific authentication page.
+
+The test users must be manually and individually added to your Cloud Project (i.e. you can not provide a group email alias for your development team because the system does not support alias expansion).
+
+Google displays a warning message before allowing a specified test user to authenticate scopes requested by your Project's OAuth clients. The warning message confirms the user has test access to your Project and reminds them that they should consider the risks associated with granting access to their data to an unverified app.
+
+For additional limitations and details about Testing Mode, see: `Setting up your OAuth consent screen <https://support.google.com/cloud/answer/10311615?hl=en#zippy=%2Ctesting>`_.
+
+To enable Testing Mode and add users to your Cloud Project, in your Project dashboard:
+
+#. Click on **APIs & Services > OAuth consent screen**.
+#. Select **External** to enable Testing Mode.
+#. Click **Create**.
+#. Fill in the necessary details related to the following:
+
+   #. App information
+   #. App domain, including Authorized domains
+   #. Developer contact information
+
+#. Click **Save and Continue**.
+#. Click **Add or Remove Scopes** to choose appropriate Scopes for your Project. An *Update selected scopes* dialogue will open.
+#. Click **Update**.
+#. Click **Save and Continue**.
+#. Click **Add Users** to add users to your Project. An *Add Users* dialogue will open.
+#. Enter the user's name in the text field.
+#. Click **Add**.
+#. Click **Save and Continue**.
+#. A summary screen will display with all the information you entered.
+
+To access BigQuery programmatically, you will need your Client ID and your Client Secret, which can be generated as follows:
+
+#. Click **APIs and Services > Credentials**.
+#. Click **+ Create Credentials > OAuth client ID**.
+#. Select Desktop app In the **Application Type** field.
+#. Fill in the name of your OAuth 2.0 client in the **Name** field.
+#. Click **Create**.
+
+Your Client ID and Client Secret are displayed in the pop-up. There is also a reminder that only test users that are listed on the Oauth consent screen can access the application. The client ID and Client Secret can also be found here, if they have already been generated:
+
+#. Click on **APIs and Services > Credentials**.
+#. Click on the name of your OAuth 2.0 Client under **OAuth 2.0 Client IDs**.
+#. The Client ID and Client Secret will be displayed.
+
+With the Client ID and Client Secret, you are ready to create an OAuth workflow using code similar to the following:
+
+To run this code sample, you will need to have ``python-bigquery-pandas`` installed. The following dependencies will be installed by ``python-bigquery-pandas``:
+
+* pydata-google-auth
+* google-auth
+* google-auth-oauthlib
+* pandas
+* google-cloud-bigquery
+* tqdm
+
+**Sample code:** ``oauth-read-from-bq-testing-mode.py``
+
+.. code:: python
+
+    import pandas_gbq
+
+    projectid = "your-project-name here"
+
+    CLIENT_ID = "your-client-id here"
+
+    # WARNING: for the purposes of this demo code, the Client Secret is
+    # included here. In your script, take precautions to ensure
+    # that your Client Secret does not get pushed to a public
+    # repository or otherwise get compromised
+    CLIENT_SECRET = "your-client-secret here"
+
+    df = pandas_gbq.read_gbq(
+        "SELECT SESSION_USER() as user_id, CURRENT_TIMESTAMP() as time",
+        project_id=projectid,
+        auth_local_webserver=False,
+        client_id=CLIENT_ID,
+        client_secret=CLIENT_SECRET,
+    )
+
+    print(df)
+
+OPTION 2 - Institution-specific authentication page
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+To access Bigquery programmatically, you will need your Client ID and your Client Secret, an OAuth authorization page, and an assigned redirect URI.
+
+To add a Client ID, Client Secret, and Redirect URI to your Cloud Project, in your Project dashboard:
+
+#. Click on **APIs & Services > OAuth consent screen**.
+#. Select **Internal**.
+#. Click **Create**.
+#. Fill in the necessary details related to the following:
+
+   #. App information
+   #. App domain, including Authorized domains
+   #. Developer contact information
+
+#. Click **Save and Continue**.
+#. Click **Add or Remove Scopes** to choose appropriate Scopes for your Project. An Update selected scopes dialogue will open.
+#. Click **Update**.
+#. Click **Save and Continue**.
+#. Click on **APIs and Services > Credentials**.
+#. Click on **+ Create Credentials > OAuth client ID**.
+#. Select Web application in the **Application Type** field.
+#. Fill in the name of your OAuth 2.0 client in the **Name** field.
+#. Click **Add Uri** under the Authorized Redirect URIs section.
+#. Add a URI for your application (i.e. the path to where you are hosting a file such as the ``oauth.html`` file shown below).
+#. Click **Create**.
+
+Your Client ID and Client Secret will be displayed in the pop-up. The client ID and Client Secret can also be found here:
+
+#. Click on **APIs and Services > Credentials**.
+#. Click on the name of your OAuth 2.0 Client under **OAuth 2.0 Client IDs**.
+#. The Client ID and Client Secret and the Authorized Redirect URIs will be displayed.
+
+You will need to host a webpage (such as ``oauth.html``) with some associated javascript (such as shown below in ``authcodescripts.js``) to parse the results of the OAuth workflow.
+
+**Code Sample**: ``oauth.html``
+
+.. code:: html
+
+    <!DOCTYPE html>
+    <html>
+    <head>
+        <script src="_static/js/authcodescripts.js"></script>
+    </head>
+    <body>
+        <h1>Sign in to BigQuery</h1>
+        <p>You are seeing this page because you are attempting to access BigQuery via one
+    of several possible methods, including:</p>
+        <blockquote>
+        <div>
+            <ul>
+                <li><p>the <code><span>pandas_gbq</span></code> library (<a href="https://github.com/googleapis/python-bigquery-pandas">https://github.com/googleapis/python-bigquery-pandas</a>)</p></li>
+            </ul>
+            <p>OR a <code><span>pandas</span></code> library helper function such as:</p>
+            <ul>
+                <li><p><code><span>pandas.DataFrame.to_gbq()</span></code></p></li>
+                <li><p><code><span>pandas.read_gbq()</span></code></p></li>
+            </ul>
+        </div>
+        </blockquote>
+        <p>from this or another machine. If this is not the case, close this tab.</p>
+        <p>Enter the following verification code in the CommandLine Interface (CLI) on the
+    machine you want to log into. This is a credential <strong>similar to your password</strong>
+    and should not be shared with others.</p>
+        <script type="text/javascript">
+        window.addEventListener( "load", onloadoauthcode )
+        </script>
+        <div>
+        <code class="auth-code"></code>
+        </div>
+        <br>
+        <button class="copy" aria-live="assertive">Copy</button>
+    </body>
+    </html>
+
+**Code Sample**: ``authcodescripts.js``
+
+.. code:: javascript
+
+    function onloadoauthcode() {
+        const PARAMS = new Proxy(new URLSearchParams(window.location.search), {
+            get: (searchParams, prop) => searchParams.get(prop),
+        });
+        const AUTH_CODE = PARAMS.code;
+        document.querySelector('.auth-code').textContent = AUTH_CODE;
+        setupCopyButton(document.querySelector('.copy'), AUTH_CODE);
+    }
+
+    function setupCopyButton(button, text) {
+        button.addEventListener('click', () => {
+            navigator.clipboard.writeText(text);
+            button.textContent = "Verification Code Copied";
+            setTimeout(() => {
+                // Remove the aria-live label so that when the
+                // button text changes back to "Copy", it is
+                // not read out.
+                button.removeAttribute("aria-live");
+                button.textContent = "Copy";
+            }, 1000);
+
+            // Re-Add the aria-live attribute to enable speech for
+            // when button text changes next time.
+            setTimeout(() => {
+                button.setAttribute("aria-live", "assertive");
+            }, 2000);
+        });
+    }
+
+With these items in place:
+
+* Client ID
+* Client Secret
+* redirect URI
+* authentication page
+
+you are ready to create an OAuth workflow using code similar to the following:
+
+To run this code sample, you will need to have ``python-bigquery-pandas`` installed. The following dependencies will be installed by ``python-bigquery-pandas``:
+
+* pydata-google-auth
+* google-auth
+* google-auth-oauthlib
+* pandas
+* google-cloud-bigquery
+* tqdm
+
+**Sample Code**: ``oauth-read-from-bq-org-specific.py``
+
+.. code:: python
+
+    import pandas_gbq
+
+    projectid = "your-project-name-here"
+
+    REDIRECT_URI = "your-redirect-uri here/oauth.html"
+    CLIENT_ID = "your-client-id here"
+
+    # WARNING: for the purposes of this demo code, the Client Secret is
+    # included here. In your script, take precautions to ensure
+    # that your Client Secret does not get pushed to a public
+    # repository or otherwise compromised
+    CLIENT_SECRET = "your-client-secret here"
+
+    df = pandas_gbq.read_gbq(
+        "SELECT SESSION_USER() as user_id, CURRENT_TIMESTAMP() as time",
+        project_id=projectid,
+        auth_local_webserver=False,
+        auth_redirect_uri=REDIRECT_URI,
+        client_id=CLIENT_ID,
+        client_secret=CLIENT_SECRET,
+    )
+
+    print(df)
diff --git a/packages/pandas-gbq/docs/index.rst b/packages/pandas-gbq/docs/index.rst
new file mode 100644
index 000000000000..14fcde286ee2
--- /dev/null
+++ b/packages/pandas-gbq/docs/index.rst
@@ -0,0 +1,67 @@
+.. pandas-gbq documentation master file, created by
+   sphinx-quickstart on Wed Feb  8 10:52:12 2017.
+   You can adapt this file completely to your liking, but it should at least
+   contain the root `toctree` directive.
+
+Welcome to pandas-gbq's documentation!
+======================================
+
+The :mod:`pandas_gbq` module provides a wrapper for Google's BigQuery
+analytics web service to simplify retrieving results from BigQuery tables
+using SQL-like queries. Result sets are parsed into a :class:`pandas.DataFrame`
+with a shape and data types derived from the source table. Additionally,
+DataFrames can be inserted into new BigQuery tables or appended to existing
+tables.
+
+Note:  The canonical version of this documentation can always be found on the
+`googleapis.dev pandas-gbq site
+<https://googleapis.dev/python/pandas-gbq/latest/index.html>`__.
+
+.. note::
+
+   To use this module, you will need a valid BigQuery account. Use the
+   `BigQuery sandbox <https://cloud.google.com/bigquery/docs/sandbox>`__ to
+   try the service for free.
+
+   Also, consider using BigQuery DataFrames 
+   (`bit.ly/bigframes-intro <https://bit.ly/bigframes-intro>`__)
+   to process large results with pandas compatible APIs with transparent SQL
+   pushdown to BigQuery engine. This provides an opportunity to save on costs
+   and improve performance.
+
+While BigQuery uses standard SQL syntax, it has some important differences
+from traditional databases both in functionality, API limitations (size and
+quantity of queries or uploads), and how Google charges for use of the
+service. BiqQuery is best for analyzing large sets of data quickly. It is not
+a direct replacement for a transactional database. Refer to the `BigQuery
+Documentation <https://cloud.google.com/bigquery/what-is-bigquery>`__ for
+details on the service itself.
+
+Contents:
+
+.. toctree::
+   :maxdepth: 2
+
+   install.rst
+   intro.rst
+   howto/authentication.rst
+   reading.rst
+   writing.rst
+   api.rst
+   contributing.rst
+   changelog.md
+   privacy.rst
+   oauth.rst
+
+
+Indices and tables
+==================
+
+* :ref:`genindex`
+* :ref:`modindex`
+* :ref:`search`
+
+.. Use the meta tags to verify the site for use in Google OAuth2 consent flow.
+
+.. meta::
+    :google-site-verification: 9QSsa9ahOZHbdwZAwl7x-Daaj1W9AttkUOeDgzKtxBw
diff --git a/packages/pandas-gbq/docs/install.rst b/packages/pandas-gbq/docs/install.rst
new file mode 100644
index 000000000000..849b1b60f118
--- /dev/null
+++ b/packages/pandas-gbq/docs/install.rst
@@ -0,0 +1,48 @@
+Installation
+============
+
+You can install pandas-gbq with ``pip`` or by installing from source.
+
+
+Pip
+---
+
+To install the latest version of pandas-gbq: from the
+
+.. code-block:: shell
+
+    $ pip install pandas-gbq -U
+
+This installs pandas-gbq and all common dependencies, including ``pandas``.
+
+
+Install from Source
+-------------------
+
+.. code-block:: shell
+
+    $ pip install git+https://github.com/googleapis/python-bigquery-pandas.git
+
+
+Dependencies
+------------
+
+This module requires following additional dependencies:
+
+- `pydata-google-auth <https://github.com/pydata/pydata-google-auth>`__: Helpers for authentication to Google's API
+- `pyarrow <https://arrow.apache.org/docs/python/>`__: Format for getting data to/from Google BigQuery
+- `google-auth <https://github.com/GoogleCloudPlatform/google-auth-library-python>`__: authentication and authorization for Google's API
+- `google-auth-oauthlib <https://github.com/GoogleCloudPlatform/google-auth-library-python-oauthlib>`__: integration with `oauthlib <https://github.com/idan/oauthlib>`__ for end-user authentication
+- `google-cloud-bigquery <https://googleapis.dev/python/bigquery/latest/index.html>`__: Google Cloud client library for BigQuery
+- `google-cloud-bigquery-storage <https://googleapis.dev/python/bigquerystorage/latest/index.html>`__: Google Cloud client library for BigQuery Storage API
+
+.. note::
+
+   The dependency on `google-cloud-bigquery <https://googleapis.dev/python/bigquery/latest/index.html>`__ is new in version 0.3.0 of ``pandas-gbq``.
+   Versions less than 0.3.0 required the following dependencies:
+
+   - `httplib2 <https://github.com/httplib2/httplib2>`__: HTTP client (no longer required)
+   - `google-api-python-client <http://github.com/google/google-api-python-client>`__: Google's API client (no longer required, replaced by `google-cloud-bigquery <hhttps://googleapis.dev/python/bigquery/latest/index.html>`__:)
+   - `google-auth <https://github.com/GoogleCloudPlatform/google-auth-library-python>`__: authentication and authorization for Google's API
+   - `google-auth-oauthlib <https://github.com/GoogleCloudPlatform/google-auth-library-python-oauthlib>`__: integration with `oauthlib <https://github.com/idan/oauthlib>`__ for end-user authentication
+   - `google-auth-httplib2 <https://github.com/GoogleCloudPlatform/google-auth-library-python-httplib2>`__: adapter to use ``httplib2`` HTTP client with ``google-auth`` (no longer required)
diff --git a/packages/pandas-gbq/docs/intro.rst b/packages/pandas-gbq/docs/intro.rst
new file mode 100644
index 000000000000..3bb60ba77a06
--- /dev/null
+++ b/packages/pandas-gbq/docs/intro.rst
@@ -0,0 +1,68 @@
+Introduction
+============
+
+The pandas-gbq package reads data from `Google BigQuery
+<https://cloud.google.com/bigquery/docs/>`__ to a :class:`pandas.DataFrame`
+object and also writes :class:`pandas.DataFrame` objects to BigQuery tables.
+
+Authenticating to BigQuery
+--------------------------
+
+Before you begin, you must create a Google Cloud Platform project. Use the
+`BigQuery sandbox <https://cloud.google.com/bigquery/docs/sandbox>`__ to try
+the service for free.
+
+If you do not provide any credentials, this module attempts to load
+credentials from the environment. If no credentials are found, pandas-gbq
+prompts you to open a web browser, where you can grant it permissions to
+access your cloud resources. These credentials are only used locally. See the
+:doc:`privacy policy <privacy>` for details.
+
+Learn about authentication methods in the :doc:`authentication guide
+<howto/authentication>`.
+
+Reading data from BigQuery
+--------------------------
+
+Use the :func:`pandas_gbq.read_gbq` function to run a BigQuery query and
+download the results as a :class:`pandas.DataFrame` object.
+
+.. literalinclude:: ../samples/snippets/read_gbq_simple.py
+   :language: python
+   :dedent: 4
+   :start-after: [START bigquery_pandas_gbq_read_gbq_simple]
+   :end-before: [END bigquery_pandas_gbq_read_gbq_simple]
+
+By default, queries use standard SQL syntax. Visit the :doc:`reading tables
+guide <reading>` to learn about the available options.
+
+Adjusting log verbosity
+^^^^^^^^^^^^^^^^^^^^^^^
+
+Because some requests take some time, this library will log its progress of
+longer queries. IPython & Jupyter by default attach a handler to the logger.
+If you're running in another process and want to see logs, or you want to see
+more verbose logs, you can do something like:
+
+.. code-block:: python
+
+   import logging
+   logger = logging.getLogger('pandas_gbq')
+   logger.setLevel(logging.DEBUG)
+   logger.addHandler(logging.StreamHandler())
+
+Writing data to BigQuery
+------------------------
+
+Use the :func:`pandas_gbq.to_gbq` function to write a
+:class:`pandas.DataFrame` object to a BigQuery table.
+
+.. literalinclude:: ../samples/snippets/to_gbq_simple.py
+   :language: python
+   :dedent: 4
+   :start-after: [START bigquery_pandas_gbq_to_gbq_simple]
+   :end-before: [END bigquery_pandas_gbq_to_gbq_simple]
+
+The destination table and destination dataset will automatically be created.
+By default, writes to BigQuery fail if the table already exists. Visit the
+:doc:`writing tables guide <writing>` to learn about the available options.
diff --git a/packages/pandas-gbq/docs/oauth.rst b/packages/pandas-gbq/docs/oauth.rst
new file mode 100644
index 000000000000..9d633a4f8668
--- /dev/null
+++ b/packages/pandas-gbq/docs/oauth.rst
@@ -0,0 +1,39 @@
+.. image:: https://lh3.googleusercontent.com/KaU6SyiIpDKe4tyGPgt7yzGVTsfMqBvP9bL24o_4M58puYDO-nY8-BazrNk3RyhRFJA
+   :alt: gcloud CLI logo
+   :class: logo
+
+Sign in to BigQuery
+===================
+
+You are seeing this page because you are attempting to access BigQuery via one 
+of several possible methods, including: 
+  
+  * the ``pandas_gbq`` library (https://github.com/googleapis/python-bigquery-pandas)
+
+  OR a ``pandas`` library helper function such as:
+  
+  * ``pandas.DataFrame.to_gbq()``
+  * ``pandas.read_gbq()``
+
+from this or another machine. If this is not the case, close this tab.
+
+Enter the following verification code in the CommandLine Interface (CLI) on the
+machine you want to log into. This is a credential **similar to your password**
+and should not be shared with others.
+
+
+.. raw:: html
+
+   <script type="text/javascript">
+     window.addEventListener( "load", onloadoauthcode )
+   </script>
+
+   <div>
+      <code class="auth-code"></code>
+   </div>
+   <br>
+   <button class="copy" aria-live="assertive">Copy</button>
+
+.. hint::
+
+   You can close this tab when you’re done.
diff --git a/packages/pandas-gbq/docs/privacy.rst b/packages/pandas-gbq/docs/privacy.rst
new file mode 100644
index 000000000000..73185182d96d
--- /dev/null
+++ b/packages/pandas-gbq/docs/privacy.rst
@@ -0,0 +1,48 @@
+Privacy
+=======
+
+This package is a `PyData project <https://pydata.org/>`_ and is subject to
+the `NumFocus privacy policy <https://numfocus.org/privacy-policy>`_. Your
+use of Google APIs with this module is subject to each API's respective
+`terms of service <https://developers.google.com/terms/>`_.
+
+Google account and user data
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Accessing user data
+~~~~~~~~~~~~~~~~~~~
+
+The :mod:`pandas_gbq` module accesses Google Cloud Platform resources from
+your local machine. Your machine communicates directly with the Google APIs.
+
+The :func:`~pandas_gbq.read_gbq` function can read and
+write BigQuery data (and other data such as Google Sheets or Cloud Storage,
+via the federated query feature) through the BigQuery query interface via
+queries you supply.
+
+The :func:`~pandas_gbq.to_gbq` method can write data you supply to a
+BigQuery table.
+
+Storing user data
+~~~~~~~~~~~~~~~~~
+
+By default, your credentials are stored to a local file, such as
+``~/.config/pandas_gbq/bigquery_credentials.dat``. See the
+:ref:`authentication-user` guide for details. All user data is stored on
+your local machine. **Use caution when using this library on a shared
+machine**.
+
+Sharing user data
+~~~~~~~~~~~~~~~~~
+
+The pandas-gbq library only communicates with Google APIs. No user
+data is shared with PyData, NumFocus, or any other servers.
+
+Policies for application authors
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Do not use the default client ID when using the pandas-gbq library
+from an application, library, or tool. Per the `Google User Data Policy
+<https://developers.google.com/terms/api-services-user-data-policy>`_, your
+application must accurately represent itself when authenticating to Google
+API servcies.
diff --git a/packages/pandas-gbq/docs/reading.rst b/packages/pandas-gbq/docs/reading.rst
new file mode 100644
index 000000000000..5fa369a7c7b4
--- /dev/null
+++ b/packages/pandas-gbq/docs/reading.rst
@@ -0,0 +1,130 @@
+.. _reader:
+
+Reading Tables
+==============
+
+Use the :func:`pandas_gbq.read_gbq` function to run a BigQuery query and
+download the results as a :class:`pandas.DataFrame` object.
+
+.. literalinclude:: ../samples/snippets/read_gbq_simple.py
+   :language: python
+   :dedent: 4
+   :start-after: [START bigquery_pandas_gbq_read_gbq_simple]
+   :end-before: [END bigquery_pandas_gbq_read_gbq_simple]
+
+.. note::
+
+    A project ID is optional if it can be inferred during authentication, but
+    it is required when authenticating with user credentials. You can find
+    your project ID in the `Google Cloud console
+    <https://console.cloud.google.com>`__.
+
+You can define which column from BigQuery to use as an index in the
+destination DataFrame as well as a preferred column order as follows:
+
+.. code-block:: python
+
+   data_frame = pandas_gbq.read_gbq(
+       'SELECT * FROM `test_dataset.test_table`',
+       project_id=projectid,
+       index_col='index_column_name',
+       columns=['col1', 'col2'])
+
+Querying with legacy SQL syntax
+-------------------------------
+
+The ``dialect`` argument can be used to indicate whether to use
+BigQuery's ``'legacy'`` SQL or BigQuery's ``'standard'`` SQL. The
+default value is ``'standard'``.
+
+.. literalinclude:: ../samples/snippets/read_gbq_legacy.py
+   :language: python
+   :dedent: 4
+   :start-after: [START bigquery_pandas_gbq_read_gbq_legacy]
+   :end-before: [END bigquery_pandas_gbq_read_gbq_legacy]
+
+* `Standard SQL reference
+  <https://cloud.google.com/bigquery/docs/reference/standard-sql/>`__
+* `Legacy SQL reference
+  <https://cloud.google.com/bigquery/docs/reference/legacy-sql>`__
+
+.. _reading-dtypes:
+
+Inferring the DataFrame's dtypes
+--------------------------------
+
+The :func:`~pandas_gbq.read_gbq` method infers the pandas dtype for each
+column, based on the BigQuery table schema.
+
+================== =========================
+BigQuery Data Type dtype
+================== =========================
+BOOL               boolean
+INT64              Int64
+FLOAT64            float64
+TIME               dbtime
+DATE               dbdate or object
+DATETIME           datetime64[ns] or object
+TIMESTAMP          datetime64[ns, UTC] or object
+================== =========================
+
+If any DATE/DATETIME/TIMESTAMP value is outside of the range of `pandas.Timestamp.min
+<https://pandas.pydata.org/docs/reference/api/pandas.Timestamp.min.html>`__
+(1677-09-22) and `pandas.Timestamp.max
+<https://pandas.pydata.org/docs/reference/api/pandas.Timestamp.max.html>`__
+(2262-04-11), the data type maps to the pandas `object` dtype.
+
+.. _reading-bqstorage-api:
+
+Improving download performance
+------------------------------
+
+Use the BigQuery Storage API to download large (>125 MB) query results more
+quickly (but at an `increased cost
+<https://cloud.google.com/bigquery/pricing#storage-api>`__) by setting
+``use_bqstorage_api`` to ``True``.
+
+#. Enable the BigQuery Storage API on the project you are using to run
+   queries.
+
+   `Enable the API
+   <https://console.cloud.google.com/apis/library/bigquerystorage.googleapis.com>`__.
+#. Ensure you have the `bigquery.readsessions.create permission
+   <https://cloud.google.com/bigquery/docs/access-control#bq-permissions>`__. to
+   create BigQuery Storage API read sessions. This permission is provided by
+   the `bigquery.user role
+   <https://cloud.google.com/bigquery/docs/access-control#roles>`__.
+#. Install the ``google-cloud-bigquery-storage`` and ``pyarrow``
+    packages.
+
+   With pip:
+
+   .. code-block:: sh
+
+      pip install --upgrade google-cloud-bigquery-storage pyarrow
+
+#. Set ``use_bqstorage_api`` to ``True`` when calling the
+   :func:`~pandas_gbq.read_gbq` function. As of the ``google-cloud-bigquery``
+   package, version 1.11.1 or later,the function will fallback to the
+   BigQuery API if the BigQuery Storage API cannot be used, such as with
+   small query results.
+
+Advanced configuration
+----------------------
+
+You can specify the query config as parameter to use additional options of
+your job. Refer to the `JobConfiguration REST resource reference
+<https://cloud.google.com/bigquery/docs/reference/rest/v2/Job#JobConfiguration>`__
+for details.
+
+.. code-block:: python
+
+   configuration = {
+      'query': {
+        "useQueryCache": False
+      }
+   }
+   data_frame = read_gbq(
+       'SELECT * FROM `test_dataset.test_table`',
+       project_id=projectid,
+       configuration=configuration)
diff --git a/packages/pandas-gbq/docs/requirements-docs.txt b/packages/pandas-gbq/docs/requirements-docs.txt
new file mode 100644
index 000000000000..af49a2462108
--- /dev/null
+++ b/packages/pandas-gbq/docs/requirements-docs.txt
@@ -0,0 +1,7 @@
+ipython
+matplotlib
+numpydoc
+recommonmark
+sphinx
+sphinx_rtd_theme
+pandas
diff --git a/packages/pandas-gbq/docs/writing.rst b/packages/pandas-gbq/docs/writing.rst
new file mode 100644
index 000000000000..80c06a583cc8
--- /dev/null
+++ b/packages/pandas-gbq/docs/writing.rst
@@ -0,0 +1,69 @@
+.. _writer:
+
+Writing Tables
+==============
+
+Use the :func:`pandas_gbq.to_gbq` function to write a
+:class:`pandas.DataFrame` object to a BigQuery table.
+
+.. literalinclude:: ../samples/snippets/to_gbq_simple.py
+   :language: python
+   :dedent: 4
+   :start-after: [START bigquery_pandas_gbq_to_gbq_simple]
+   :end-before: [END bigquery_pandas_gbq_to_gbq_simple]
+
+The destination table and destination dataset will automatically be created
+if they do not already exist.
+
+Writing to an Existing Table
+----------------------------
+
+Use the ``if_exists`` argument to dictate whether to ``'fail'``,
+``'replace'`` or ``'append'`` if the destination table already exists. The
+default value is ``'fail'``.
+
+For example, assume that ``if_exists`` is set to ``'fail'``. The following snippet will raise
+a ``TableCreationError`` if the destination table already exists.
+
+.. code-block:: python
+
+   import pandas_gbq
+   pandas_gbq.to_gbq(
+       df, 'my_dataset.my_table', project_id=projectid, if_exists='fail',
+   )
+
+If the ``if_exists`` argument is set to ``'append'``, the destination
+dataframe will be written to the table using the defined table schema and
+column types. The dataframe must contain fields (matching name and type)
+currently in the destination table.
+
+
+.. _writing-schema:
+
+Inferring the Table Schema
+--------------------------
+
+The :func:`~pandas_gbq.to_gbq` method infers the BigQuery table schema based
+on the dtypes of the uploaded :class:`~pandas.DataFrame`.
+
+========================= ==================
+dtype                     BigQuery Data Type
+========================= ==================
+i (integer)               INTEGER
+b (boolean)               BOOLEAN
+f (float)                 FLOAT
+O (object)                STRING
+S (zero-terminated bytes) STRING
+U (Unicode string)        STRING
+M (datetime)              TIMESTAMP
+========================= ==================
+
+If the data type inference does not suit your needs, supply a BigQuery schema
+as the ``table_schema`` parameter of :func:`~pandas_gbq.to_gbq`.
+
+
+Troubleshooting Errors
+----------------------
+
+If an error occurs while writing data to BigQuery, see
+`Troubleshooting BigQuery Errors <https://cloud.google.com/bigquery/troubleshooting-errors>`__.
diff --git a/packages/pandas-gbq/noxfile.py b/packages/pandas-gbq/noxfile.py
new file mode 100644
index 000000000000..e2e9f7234e97
--- /dev/null
+++ b/packages/pandas-gbq/noxfile.py
@@ -0,0 +1,502 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright 2018 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.
+
+# Generated by synthtool. DO NOT EDIT!
+
+from __future__ import absolute_import
+
+from functools import wraps
+import os
+import pathlib
+import re
+import shutil
+import time
+import warnings
+
+import nox
+
+BLACK_VERSION = "black==23.7.0"
+ISORT_VERSION = "isort==5.10.1"
+LINT_PATHS = ["docs", "pandas_gbq", "tests", "noxfile.py", "setup.py"]
+
+DEFAULT_PYTHON_VERSION = "3.10"
+
+UNIT_TEST_PYTHON_VERSIONS = ["3.9", "3.10", "3.11", "3.12", "3.13"]
+UNIT_TEST_STANDARD_DEPENDENCIES = [
+    "mock",
+    "asyncmock",
+    "pytest",
+    "pytest-cov",
+    "pytest-asyncio",
+]
+UNIT_TEST_EXTERNAL_DEPENDENCIES = [
+    "freezegun",
+]
+UNIT_TEST_LOCAL_DEPENDENCIES = []
+UNIT_TEST_DEPENDENCIES = []
+UNIT_TEST_EXTRAS = [
+    "bqstorage",
+    "tqdm",
+    "geopandas",
+]
+UNIT_TEST_EXTRAS_BY_PYTHON = {
+    "3.9": [],
+}
+
+SYSTEM_TEST_PYTHON_VERSIONS = ["3.9", "3.10", "3.11", "3.12", "3.13"]
+SYSTEM_TEST_STANDARD_DEPENDENCIES = [
+    "mock",
+    "pytest",
+    "google-cloud-testutils",
+]
+SYSTEM_TEST_EXTERNAL_DEPENDENCIES = []
+SYSTEM_TEST_LOCAL_DEPENDENCIES = []
+SYSTEM_TEST_DEPENDENCIES = []
+SYSTEM_TEST_EXTRAS = [
+    "tqdm",
+]
+SYSTEM_TEST_EXTRAS_BY_PYTHON = {}
+
+CURRENT_DIRECTORY = pathlib.Path(__file__).parent.absolute()
+
+# Error if a python version is missing
+nox.options.error_on_missing_interpreters = True
+
+
+def _calculate_duration(func):
+    """This decorator prints the execution time for the decorated function."""
+
+    @wraps(func)
+    def wrapper(*args, **kwargs):
+        start = time.monotonic()
+        result = func(*args, **kwargs)
+        end = time.monotonic()
+        total_seconds = round(end - start)
+        hours = total_seconds // 3600  # Integer division to get hours
+        remaining_seconds = total_seconds % 3600  # Modulo to find remaining seconds
+        minutes = remaining_seconds // 60
+        seconds = remaining_seconds % 60
+        human_time = f"{hours:}:{minutes:0>2}:{seconds:0>2}"
+        print(f"Session ran in {total_seconds} seconds ({human_time})")
+        return result
+
+    return wrapper
+
+
+# 'docfx' is excluded since it only needs to run in 'docs-presubmit'
+nox.options.sessions = [
+    "lint",
+    "lint_setup_py",
+    "blacken",
+    "docs",
+]
+
+# Error if a python version is missing
+nox.options.error_on_missing_interpreters = True
+
+
+@nox.session(python=DEFAULT_PYTHON_VERSION)
+@_calculate_duration
+def lint(session):
+    """Run linters.
+
+    Returns a failure if the linters find linting errors or sufficiently
+    serious code quality issues.
+    """
+    session.install("flake8", BLACK_VERSION)
+    session.run(
+        "black",
+        "--check",
+        *LINT_PATHS,
+    )
+    session.run("flake8", "pandas_gbq", "tests")
+
+
+@nox.session(python=DEFAULT_PYTHON_VERSION)
+@_calculate_duration
+def blacken(session):
+    """Run black. Format code to uniform standard."""
+    session.install(BLACK_VERSION)
+    session.run(
+        "black",
+        *LINT_PATHS,
+    )
+
+
+@nox.session(python=DEFAULT_PYTHON_VERSION)
+@_calculate_duration
+def format(session):
+    """
+    Run isort to sort imports. Then run black
+    to format code to uniform standard.
+    """
+    session.install(BLACK_VERSION, ISORT_VERSION)
+    # Use the --fss option to sort imports using strict alphabetical order.
+    # See https://pycqa.github.io/isort/docs/configuration/options.html#force-sort-within-sections
+    session.run(
+        "isort",
+        "--fss",
+        *LINT_PATHS,
+    )
+    session.run(
+        "black",
+        *LINT_PATHS,
+    )
+
+
+@nox.session(python=DEFAULT_PYTHON_VERSION)
+@_calculate_duration
+def lint_setup_py(session):
+    """Verify that setup.py is valid (including RST check)."""
+    session.install("docutils", "pygments")
+    session.run("python", "setup.py", "check", "--restructuredtext", "--strict")
+
+
+def install_unittest_dependencies(session, *constraints):
+    standard_deps = UNIT_TEST_STANDARD_DEPENDENCIES + UNIT_TEST_DEPENDENCIES
+    session.install(*standard_deps, *constraints)
+
+    if UNIT_TEST_EXTERNAL_DEPENDENCIES:
+        warnings.warn(
+            "'unit_test_external_dependencies' is deprecated. Instead, please "
+            "use 'unit_test_dependencies' or 'unit_test_local_dependencies'.",
+            DeprecationWarning,
+        )
+        session.install(*UNIT_TEST_EXTERNAL_DEPENDENCIES, *constraints)
+
+    if UNIT_TEST_LOCAL_DEPENDENCIES:
+        session.install(*UNIT_TEST_LOCAL_DEPENDENCIES, *constraints)
+
+    if UNIT_TEST_EXTRAS_BY_PYTHON:
+        extras = UNIT_TEST_EXTRAS_BY_PYTHON.get(session.python, [])
+    elif UNIT_TEST_EXTRAS:
+        extras = UNIT_TEST_EXTRAS
+    else:
+        extras = []
+
+    if extras:
+        session.install("-e", f".[{','.join(extras)}]", *constraints)
+    else:
+        session.install("-e", ".", *constraints)
+
+
+def default(session):
+    # Install all test dependencies, then install this package in-place.
+
+    constraints_path = str(
+        CURRENT_DIRECTORY / "testing" / f"constraints-{session.python}.txt"
+    )
+    install_unittest_dependencies(session, "-c", constraints_path)
+
+    session.run("python", "-m", "pip", "freeze")
+
+    # Run py.test against the unit tests.
+    session.run(
+        "py.test",
+        "--quiet",
+        "-W default::PendingDeprecationWarning",
+        f"--junitxml=unit_{session.python}_sponge_log.xml",
+        "--cov=pandas_gbq",
+        "--cov=tests/unit",
+        "--cov-append",
+        "--cov-config=.coveragerc",
+        "--cov-report=",
+        "--cov-fail-under=0",
+        os.path.join("tests", "unit"),
+        *session.posargs,
+    )
+
+
+@nox.session(python=UNIT_TEST_PYTHON_VERSIONS)
+@_calculate_duration
+def unit(session):
+    """Run the unit test suite."""
+    default(session)
+
+
+def install_systemtest_dependencies(session, *constraints):
+    # Use pre-release gRPC for system tests.
+    # Exclude version 1.52.0rc1 which has a known issue.
+    # See https://github.com/grpc/grpc/issues/32163
+    session.install("--pre", "grpcio!=1.52.0rc1")
+
+    session.install(*SYSTEM_TEST_STANDARD_DEPENDENCIES, *constraints)
+
+    if SYSTEM_TEST_EXTERNAL_DEPENDENCIES:
+        session.install(*SYSTEM_TEST_EXTERNAL_DEPENDENCIES, *constraints)
+
+    if SYSTEM_TEST_LOCAL_DEPENDENCIES:
+        session.install("-e", *SYSTEM_TEST_LOCAL_DEPENDENCIES, *constraints)
+
+    if SYSTEM_TEST_DEPENDENCIES:
+        session.install("-e", *SYSTEM_TEST_DEPENDENCIES, *constraints)
+
+    if SYSTEM_TEST_EXTRAS_BY_PYTHON:
+        extras = SYSTEM_TEST_EXTRAS_BY_PYTHON.get(session.python, [])
+    elif SYSTEM_TEST_EXTRAS:
+        extras = SYSTEM_TEST_EXTRAS
+    else:
+        extras = []
+
+    if extras:
+        session.install("-e", f".[{','.join(extras)}]", *constraints)
+    else:
+        session.install("-e", ".", *constraints)
+
+
+@nox.session(python=SYSTEM_TEST_PYTHON_VERSIONS)
+@_calculate_duration
+def system(session):
+    """Run the system test suite."""
+    constraints_path = str(
+        CURRENT_DIRECTORY / "testing" / f"constraints-{session.python}.txt"
+    )
+    system_test_path = os.path.join("tests", "system.py")
+    system_test_folder_path = os.path.join("tests", "system")
+
+    # Check the value of `RUN_SYSTEM_TESTS` env var. It defaults to true.
+    if os.environ.get("RUN_SYSTEM_TESTS", "true") == "false":
+        session.skip("RUN_SYSTEM_TESTS is set to false, skipping")
+    # Install pyopenssl for mTLS testing.
+    if os.environ.get("GOOGLE_API_USE_CLIENT_CERTIFICATE", "false") == "true":
+        session.install("pyopenssl")
+
+    system_test_exists = os.path.exists(system_test_path)
+    system_test_folder_exists = os.path.exists(system_test_folder_path)
+    # Sanity check: only run tests if found.
+    if not system_test_exists and not system_test_folder_exists:
+        session.skip("System tests were not found")
+
+    install_systemtest_dependencies(session, "-c", constraints_path)
+
+    # Print out package versions.
+    session.run("python", "-m", "pip", "freeze")
+
+    # Run py.test against the system tests.
+    if system_test_exists:
+        session.run(
+            "py.test",
+            "--quiet",
+            "-W default::PendingDeprecationWarning",
+            f"--junitxml=system_{session.python}_sponge_log.xml",
+            system_test_path,
+            *session.posargs,
+        )
+    if system_test_folder_exists:
+        session.run(
+            "py.test",
+            "--quiet",
+            "-W default::PendingDeprecationWarning",
+            f"--junitxml=system_{session.python}_sponge_log.xml",
+            system_test_folder_path,
+            *session.posargs,
+        )
+
+
+@nox.session(python=DEFAULT_PYTHON_VERSION)
+@_calculate_duration
+def prerelease(session):
+    session.install(
+        # https://arrow.apache.org/docs/developers/python.html#installing-nightly-packages
+        "--extra-index-url",
+        "https://pypi.fury.io/arrow-nightlies/",
+        "--prefer-binary",
+        "--pre",
+        "--upgrade",
+        "pyarrow",
+    )
+    session.install(
+        "--prefer-binary",
+        "--pre",
+        "--upgrade",
+        "google-api-core",
+        "google-cloud-core",
+        "google-resumable-media",
+        # Exclude version 1.49.0rc1 which has a known issue. See https://github.com/grpc/grpc/pull/30642
+        "grpcio!=1.49.0rc1",
+        "pandas",
+    )
+    session.install(
+        "freezegun",
+        "google-cloud-datacatalog",
+        "google-cloud-storage",
+        "google-cloud-testutils",
+        "IPython",
+        "mock",
+        "psutil",
+        "pytest",
+        "pytest-cov",
+    )
+
+    # Install python-bigquery and python-bigquery-storage from main to detect
+    # any potential breaking changes. For context, see:
+    # https://github.com/googleapis/python-bigquery-pandas/issues/854
+    session.install(
+        "https://github.com/googleapis/python-bigquery/archive/main.zip",
+        "git+https://github.com/googleapis/google-cloud-python.git@main#subdirectory=packages/google-cloud-bigquery-storage",
+    )
+
+    # Because we test minimum dependency versions on the minimum Python
+    # version, the first version we test with in the unit tests sessions has a
+    # constraints file containing all dependencies and extras.
+    with open(
+        CURRENT_DIRECTORY
+        / "testing"
+        / f"constraints-{UNIT_TEST_PYTHON_VERSIONS[0]}.txt",
+        encoding="utf-8",
+    ) as constraints_file:
+        constraints_text = constraints_file.read()
+
+    # Ignore leading whitespace and comment lines.
+    constraints_deps = [
+        match.group(1)
+        for match in re.finditer(
+            r"^\s*(\S+)(?===\S+)", constraints_text, flags=re.MULTILINE
+        )
+    ]
+
+    # We use --no-deps to ensure that pre-release versions aren't overwritten
+    # by the version ranges in setup.py.
+    session.install(*constraints_deps)
+    session.install("--no-deps", "-e", ".[all]")
+
+    # Print out prerelease package versions.
+    session.run("python", "-m", "pip", "freeze")
+
+    # Run all tests, except a few samples tests which require extra dependencies.
+    session.run(
+        "py.test",
+        "--quiet",
+        "-W default::PendingDeprecationWarning",
+        f"--junitxml=prerelease_unit_{session.python}_sponge_log.xml",
+        os.path.join("tests", "unit"),
+        *session.posargs,
+    )
+
+    session.run(
+        "py.test",
+        "--quiet",
+        "-W default::PendingDeprecationWarning",
+        f"--junitxml=prerelease_system_{session.python}_sponge_log.xml",
+        os.path.join("tests", "system"),
+        *session.posargs,
+    )
+
+
+@nox.session(python=DEFAULT_PYTHON_VERSION)
+@_calculate_duration
+def cover(session):
+    """Run the final coverage report.
+
+    This outputs the coverage report aggregating coverage from the unit
+    test runs (not system test runs), and then erases coverage data.
+    """
+    session.install("coverage", "pytest-cov")
+    session.run("coverage", "report", "--show-missing", "--fail-under=96")
+
+    # Make sure there is no dead code in our test directories.
+    session.run(
+        "coverage",
+        "report",
+        "--show-missing",
+        "--include=tests/unit/*",
+        "--fail-under=100",
+    )
+
+    session.run("coverage", "erase")
+
+
+@nox.session(python="3.10")
+@_calculate_duration
+def docs(session):
+    """Build the docs for this library."""
+
+    session.install("-e", ".")
+    session.install(
+        # We need to pin to specific versions of the `sphinxcontrib-*` packages
+        # which still support sphinx 4.x.
+        # See https://github.com/googleapis/sphinx-docfx-yaml/issues/344
+        # and https://github.com/googleapis/sphinx-docfx-yaml/issues/345.
+        "sphinxcontrib-applehelp==1.0.4",
+        "sphinxcontrib-devhelp==1.0.2",
+        "sphinxcontrib-htmlhelp==2.0.1",
+        "sphinxcontrib-qthelp==1.0.3",
+        "sphinxcontrib-serializinghtml==1.1.5",
+        "sphinx==4.5.0",
+        "alabaster",
+        "recommonmark",
+    )
+
+    shutil.rmtree(os.path.join("docs", "_build"), ignore_errors=True)
+    session.run(
+        "sphinx-build",
+        "-W",  # warnings as errors
+        "-T",  # show full traceback on exception
+        "-N",  # no colors
+        "-b",
+        "html",
+        "-d",
+        os.path.join("docs", "_build", "doctrees", ""),
+        os.path.join("docs", ""),
+        os.path.join("docs", "_build", "html", ""),
+    )
+
+
+@nox.session(python="3.10")
+@_calculate_duration
+def docfx(session):
+    """Build the docfx yaml files for this library."""
+
+    session.install("-e", ".")
+    session.install(
+        # We need to pin to specific versions of the `sphinxcontrib-*` packages
+        # which still support sphinx 4.x.
+        # See https://github.com/googleapis/sphinx-docfx-yaml/issues/344
+        # and https://github.com/googleapis/sphinx-docfx-yaml/issues/345.
+        "sphinxcontrib-applehelp==1.0.4",
+        "sphinxcontrib-devhelp==1.0.2",
+        "sphinxcontrib-htmlhelp==2.0.1",
+        "sphinxcontrib-qthelp==1.0.3",
+        "sphinxcontrib-serializinghtml==1.1.5",
+        "gcp-sphinx-docfx-yaml",
+        "alabaster",
+        "recommonmark",
+    )
+
+    shutil.rmtree(os.path.join("docs", "_build"), ignore_errors=True)
+    session.run(
+        "sphinx-build",
+        "-T",  # show full traceback on exception
+        "-N",  # no colors
+        "-D",
+        (
+            "extensions=sphinx.ext.autodoc,"
+            "sphinx.ext.autosummary,"
+            "docfx_yaml.extension,"
+            "sphinx.ext.intersphinx,"
+            "sphinx.ext.coverage,"
+            "sphinx.ext.napoleon,"
+            "sphinx.ext.todo,"
+            "sphinx.ext.viewcode,"
+            "recommonmark"
+        ),
+        "-b",
+        "html",
+        "-d",
+        os.path.join("docs", "_build", "doctrees", ""),
+        os.path.join("docs", ""),
+        os.path.join("docs", "_build", "html", ""),
+    )
diff --git a/packages/pandas-gbq/pandas_gbq/__init__.py b/packages/pandas-gbq/pandas_gbq/__init__.py
new file mode 100644
index 000000000000..0c2438696585
--- /dev/null
+++ b/packages/pandas-gbq/pandas_gbq/__init__.py
@@ -0,0 +1,37 @@
+# Copyright (c) 2017 pandas-gbq Authors All rights reserved.
+# Use of this source code is governed by a BSD-style
+# license that can be found in the LICENSE file.
+
+import logging
+import warnings
+
+from pandas_gbq import version as pandas_gbq_version
+from pandas_gbq.contexts import Context, context
+from pandas_gbq.core.sample import sample
+
+from . import _versions_helpers
+from .gbq import read_gbq, to_gbq  # noqa
+
+sys_major, sys_minor, sys_micro = _versions_helpers.extract_runtime_version()
+if sys_major == 3 and sys_minor < 9:
+    warnings.warn(
+        "pandas-gbq no longer supports Python versions older than 3.9. "
+        "Your Python version is "
+        f"{sys_major}.{sys_minor}.{sys_micro}. Please update "
+        "to Python 3.9 or newer to ensure ongoing support. For more details, "
+        "see: https://cloud.google.com/python/docs/supported-python-versions",
+        FutureWarning,
+    )
+
+logger = logging.Logger(__name__)
+
+__version__ = pandas_gbq_version.__version__
+
+__all__ = [
+    "__version__",
+    "to_gbq",
+    "read_gbq",
+    "Context",
+    "context",
+    "sample",
+]
diff --git a/packages/pandas-gbq/pandas_gbq/_versions_helpers.py b/packages/pandas-gbq/pandas_gbq/_versions_helpers.py
new file mode 100644
index 000000000000..37247c456d81
--- /dev/null
+++ b/packages/pandas-gbq/pandas_gbq/_versions_helpers.py
@@ -0,0 +1,32 @@
+# 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
+#
+#     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.
+
+"""Shared helper functions for verifying versions of installed modules."""
+
+
+import sys
+from typing import Tuple
+
+
+def extract_runtime_version() -> Tuple[int, int, int]:
+    # Retrieve the version information
+    version_info = sys.version_info
+
+    # Extract the major, minor, and micro components
+    major = version_info.major
+    minor = version_info.minor
+    micro = version_info.micro
+
+    # Display the version number in a clear format
+    return major, minor, micro
diff --git a/packages/pandas-gbq/pandas_gbq/auth.py b/packages/pandas-gbq/pandas_gbq/auth.py
new file mode 100644
index 000000000000..704f15be1c0c
--- /dev/null
+++ b/packages/pandas-gbq/pandas_gbq/auth.py
@@ -0,0 +1,60 @@
+# Copyright (c) 2017 pandas-gbq Authors All rights reserved.
+# Use of this source code is governed by a BSD-style
+# license that can be found in the LICENSE file.
+
+"""Private module for fetching Google BigQuery credentials."""
+
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+CREDENTIALS_CACHE_DIRNAME = "pandas_gbq"
+CREDENTIALS_CACHE_FILENAME = "bigquery_credentials.dat"
+SCOPES = ["https://www.googleapis.com/auth/bigquery"]
+
+
+def get_credentials(
+    private_key=None,
+    project_id=None,
+    reauth=False,
+    auth_local_webserver=True,
+    auth_redirect_uri=None,
+    client_id=None,
+    client_secret=None,
+):
+    import pydata_google_auth
+
+    if private_key:
+        raise NotImplementedError(
+            """The private_key argument is deprecated. Construct a credentials
+object, instead, by using the
+google.oauth2.service_account.Credentials.from_service_account_file or
+google.oauth2.service_account.Credentials.from_service_account_info class
+method from the google-auth package."""
+        )
+
+    credentials, default_project_id = pydata_google_auth.default(
+        SCOPES,
+        client_id=client_id,
+        client_secret=client_secret,
+        credentials_cache=get_credentials_cache(reauth),
+        auth_local_webserver=auth_local_webserver,
+        redirect_uri=auth_redirect_uri,
+    )
+
+    project_id = project_id or default_project_id
+    return credentials, project_id
+
+
+def get_credentials_cache(reauth):
+    import pydata_google_auth.cache
+
+    if reauth:
+        return pydata_google_auth.cache.WriteOnlyCredentialsCache(
+            dirname=CREDENTIALS_CACHE_DIRNAME,
+            filename=CREDENTIALS_CACHE_FILENAME,
+        )
+    return pydata_google_auth.cache.ReadWriteCredentialsCache(
+        dirname=CREDENTIALS_CACHE_DIRNAME, filename=CREDENTIALS_CACHE_FILENAME
+    )
diff --git a/packages/pandas-gbq/pandas_gbq/constants.py b/packages/pandas-gbq/pandas_gbq/constants.py
new file mode 100644
index 000000000000..498b03b5d8c1
--- /dev/null
+++ b/packages/pandas-gbq/pandas_gbq/constants.py
@@ -0,0 +1,19 @@
+# Copyright (c) 2024 pandas-gbq Authors All rights reserved.
+# Use of this source code is governed by a BSD-style
+# license that can be found in the LICENSE file.
+
+import google.api_core.exceptions
+
+# BigQuery uses powers of 2 in calculating data sizes. See:
+# https://cloud.google.com/bigquery/pricing#data The documentation uses
+# GiB rather than GB to disambiguate from the alternative base 10 units.
+# https://en.wikipedia.org/wiki/Byte#Multiple-byte_units
+BYTES_IN_KIB = 1024
+BYTES_IN_MIB = 1024 * BYTES_IN_KIB
+BYTES_IN_GIB = 1024 * BYTES_IN_MIB
+BYTES_TO_RECOMMEND_BIGFRAMES = BYTES_IN_GIB
+
+HTTP_ERRORS = (
+    google.api_core.exceptions.ClientError,
+    google.api_core.exceptions.GoogleAPIError,
+)
diff --git a/packages/pandas-gbq/pandas_gbq/contexts.py b/packages/pandas-gbq/pandas_gbq/contexts.py
new file mode 100644
index 000000000000..76a5a1e2efda
--- /dev/null
+++ b/packages/pandas-gbq/pandas_gbq/contexts.py
@@ -0,0 +1,120 @@
+# Copyright (c) 2025 pandas-gbq Authors All rights reserved.
+# Use of this source code is governed by a BSD-style
+# license that can be found in the LICENSE file.
+
+
+class Context(object):
+    """Storage for objects to be used throughout a session.
+
+    A Context object is initialized when the ``pandas_gbq`` module is
+    imported, and can be found at :attr:`pandas_gbq.context`.
+    """
+
+    def __init__(self):
+        self._credentials = None
+        self._project = None
+        # dialect defaults to None so that read_gbq can stop warning if set.
+        self._dialect = None
+
+    @property
+    def credentials(self):
+        """
+        Credentials to use for Google APIs.
+
+        These credentials are automatically cached in memory by calls to
+        :func:`pandas_gbq.read_gbq` and :func:`pandas_gbq.to_gbq`. To
+        manually set the credentials, construct an
+        :class:`google.auth.credentials.Credentials` object and set it as
+        the context credentials as demonstrated in the example below. See
+        `auth docs`_ for more information on obtaining credentials.
+
+        .. _auth docs: http://google-auth.readthedocs.io
+            /en/latest/user-guide.html#obtaining-credentials
+
+        Returns
+        -------
+        google.auth.credentials.Credentials
+
+        Examples
+        --------
+
+        Manually setting the context credentials:
+
+        >>> import pandas_gbq
+        >>> from google.oauth2 import service_account
+        >>> credentials = service_account.Credentials.from_service_account_file(
+        ...     '/path/to/key.json',
+        ... )
+        >>> pandas_gbq.context.credentials = credentials
+        """
+        return self._credentials
+
+    @credentials.setter
+    def credentials(self, value):
+        self._credentials = value
+
+    @property
+    def project(self):
+        """Default project to use for calls to Google APIs.
+
+        Returns
+        -------
+        str
+
+        Examples
+        --------
+
+        Manually setting the context project:
+
+        >>> import pandas_gbq
+        >>> pandas_gbq.context.project = 'my-project'
+        """
+        return self._project
+
+    @project.setter
+    def project(self, value):
+        self._project = value
+
+    @property
+    def dialect(self):
+        """
+        Default dialect to use in :func:`pandas_gbq.read_gbq`.
+
+        Allowed values for the BigQuery SQL syntax dialect:
+
+        ``'legacy'``
+            Use BigQuery's legacy SQL dialect. For more information see
+            `BigQuery Legacy SQL Reference
+            <https://cloud.google.com/bigquery/docs/reference/legacy-sql>`__.
+        ``'standard'``
+            Use BigQuery's standard SQL, which is
+            compliant with the SQL 2011 standard. For more information
+            see `BigQuery Standard SQL Reference
+            <https://cloud.google.com/bigquery/docs/reference/standard-sql/>`__.
+
+        Returns
+        -------
+        str
+
+        Examples
+        --------
+
+        Setting the default syntax to standard:
+
+        >>> import pandas_gbq
+        >>> pandas_gbq.context.dialect = 'standard'
+        """
+        return self._dialect
+
+    @dialect.setter
+    def dialect(self, value):
+        self._dialect = value
+
+
+# Create an empty context, used to cache credentials.
+context = Context()
+"""A :class:`pandas_gbq.Context` object used to cache credentials.
+
+Credentials automatically are cached in-memory by :func:`pandas_gbq.read_gbq`
+and :func:`pandas_gbq.to_gbq`.
+"""
diff --git a/packages/pandas-gbq/pandas_gbq/core/__init__.py b/packages/pandas-gbq/pandas_gbq/core/__init__.py
new file mode 100644
index 000000000000..02d26e8e8fb8
--- /dev/null
+++ b/packages/pandas-gbq/pandas_gbq/core/__init__.py
@@ -0,0 +1,3 @@
+# Copyright (c) 2024 pandas-gbq Authors All rights reserved.
+# Use of this source code is governed by a BSD-style
+# license that can be found in the LICENSE file.
diff --git a/packages/pandas-gbq/pandas_gbq/core/pandas.py b/packages/pandas-gbq/pandas_gbq/core/pandas.py
new file mode 100644
index 000000000000..37557adf8b70
--- /dev/null
+++ b/packages/pandas-gbq/pandas_gbq/core/pandas.py
@@ -0,0 +1,70 @@
+# Copyright (c) 2019 pandas-gbq Authors All rights reserved.
+# Use of this source code is governed by a BSD-style
+# license that can be found in the LICENSE file.
+
+import itertools
+
+import pandas
+
+
+def list_columns_and_indexes(dataframe, index=True):
+    """Return all index and column names with dtypes.
+
+    Returns:
+        Sequence[Tuple[str, dtype]]:
+            Returns a sorted list of indexes and column names with
+            corresponding dtypes. If an index is missing a name or has the
+            same name as a column, the index is omitted.
+    """
+    column_names = frozenset(dataframe.columns)
+    columns_and_indexes = []
+    if index:
+        if isinstance(dataframe.index, pandas.MultiIndex):
+            for name in dataframe.index.names:
+                if name and name not in column_names:
+                    values = dataframe.index.get_level_values(name)
+                    columns_and_indexes.append((name, values.dtype))
+        else:
+            if dataframe.index.name and dataframe.index.name not in column_names:
+                columns_and_indexes.append(
+                    (dataframe.index.name, dataframe.index.dtype)
+                )
+
+    columns_and_indexes += zip(dataframe.columns, dataframe.dtypes)
+    return columns_and_indexes
+
+
+def first_valid(series):
+    first_valid_index = series.first_valid_index()
+    if first_valid_index is not None:
+        return series.at[first_valid_index]
+
+
+def first_array_valid(series):
+    """Return the first "meaningful" element from the array series.
+
+    Here, "meaningful" means the first non-None element in one of the arrays that can
+    be used for type detextion.
+    """
+    first_valid_index = series.first_valid_index()
+    if first_valid_index is None:
+        return None
+
+    valid_array = series.at[first_valid_index]
+    valid_item = next((item for item in valid_array if not pandas.isna(item)), None)
+
+    if valid_item is not None:
+        return valid_item
+
+    # Valid item is None because all items in the "valid" array are invalid. Try
+    # to find a true valid array manually.
+    for array in itertools.islice(series, first_valid_index + 1, None):
+        try:
+            array_iter = iter(array)
+        except TypeError:
+            continue  # Not an array, apparently, e.g. None, thus skip.
+        valid_item = next((item for item in array_iter if not pandas.isna(item)), None)
+        if valid_item is not None:
+            break
+
+    return valid_item
diff --git a/packages/pandas-gbq/pandas_gbq/core/read.py b/packages/pandas-gbq/pandas_gbq/core/read.py
new file mode 100644
index 000000000000..bc0890021b33
--- /dev/null
+++ b/packages/pandas-gbq/pandas_gbq/core/read.py
@@ -0,0 +1,179 @@
+# Copyright (c) 2025 pandas-gbq Authors All rights reserved.
+# Use of this source code is governed by a BSD-style
+# license that can be found in the LICENSE file.
+
+from __future__ import annotations
+
+import typing
+from typing import Any, Dict, Optional, Sequence
+import warnings
+
+import google.cloud.bigquery
+import google.cloud.bigquery.table
+import numpy as np
+
+import pandas_gbq
+import pandas_gbq.constants
+import pandas_gbq.exceptions
+import pandas_gbq.features
+import pandas_gbq.timestamp
+
+# Only import at module-level at type checking time to avoid circular
+# dependencies in the pandas package, which has an optional dependency on
+# pandas-gbq.
+if typing.TYPE_CHECKING:  # pragma: NO COVER
+    import pandas
+
+
+def _bqschema_to_nullsafe_dtypes(schema_fields):
+    """Specify explicit dtypes based on BigQuery schema.
+
+    This function only specifies a dtype when the dtype allows nulls.
+    Otherwise, use pandas's default dtype choice.
+
+    See: http://pandas.pydata.org/pandas-docs/dev/missing_data.html
+    #missing-data-casting-rules-and-indexing
+    """
+    import db_dtypes
+
+    # If you update this mapping, also update the table at
+    # `docs/reading.rst`.
+    dtype_map = {
+        "FLOAT": np.dtype(float),
+        "INTEGER": "Int64",
+        "TIME": db_dtypes.TimeDtype(),
+        # Note: Other types such as 'datetime64[ns]' and db_types.DateDtype()
+        # are not included because the pandas range does not align with the
+        # BigQuery range. We need to attempt a conversion to those types and
+        # fall back to 'object' when there are out-of-range values.
+    }
+
+    # Amend dtype_map with newer extension types if pandas version allows.
+    if pandas_gbq.features.FEATURES.pandas_has_boolean_dtype:
+        dtype_map["BOOLEAN"] = "boolean"
+
+    dtypes = {}
+    for field in schema_fields:
+        name = str(field["name"])
+        # Array BigQuery type is represented as an object column containing
+        # list objects.
+        if field["mode"].upper() == "REPEATED":
+            dtypes[name] = "object"
+            continue
+
+        dtype = dtype_map.get(field["type"].upper())
+        if dtype:
+            dtypes[name] = dtype
+
+    return dtypes
+
+
+def _finalize_dtypes(
+    df: pandas.DataFrame, schema_fields: Sequence[Dict[str, Any]]
+) -> pandas.DataFrame:
+    """
+    Attempt to change the dtypes of those columns that don't map exactly.
+
+    For example db_dtypes.DateDtype() and datetime64[ns] cannot represent
+    0001-01-01, but they can represent dates within a couple hundred years of
+    1970. See:
+    https://github.com/googleapis/python-bigquery-pandas/issues/365
+    """
+    import db_dtypes
+    import pandas.api.types
+
+    # If you update this mapping, also update the table at
+    # `docs/reading.rst`.
+    dtype_map = {
+        "DATE": db_dtypes.DateDtype(),
+        "DATETIME": "datetime64[ns]",
+        "TIMESTAMP": "datetime64[ns]",
+    }
+
+    for field in schema_fields:
+        # This method doesn't modify ARRAY/REPEATED columns.
+        if field["mode"].upper() == "REPEATED":
+            continue
+
+        name = str(field["name"])
+        dtype = dtype_map.get(field["type"].upper())
+
+        # Avoid deprecated conversion to timezone-naive dtype by only casting
+        # object dtypes.
+        if dtype and pandas.api.types.is_object_dtype(df[name]):
+            df[name] = df[name].astype(dtype, errors="ignore")
+
+    # Ensure any TIMESTAMP columns are tz-aware.
+    df = pandas_gbq.timestamp.localize_df(df, schema_fields)
+
+    return df
+
+
+def download_results(
+    results: google.cloud.bigquery.table.RowIterator,
+    *,
+    bqclient: google.cloud.bigquery.Client,
+    progress_bar_type: Optional[str],
+    warn_on_large_results: bool = True,
+    max_results: Optional[int],
+    user_dtypes: Optional[dict],
+    use_bqstorage_api: bool,
+) -> Optional[pandas.DataFrame]:
+    # No results are desired, so don't bother downloading anything.
+    if max_results == 0:
+        return None
+
+    if user_dtypes is None:
+        user_dtypes = {}
+
+    create_bqstorage_client = use_bqstorage_api
+    if max_results is not None:
+        create_bqstorage_client = False
+
+    # If we're downloading a large table, BigQuery DataFrames might be a
+    # better fit. Not all code paths will populate rows_iter._table, but
+    # if it's not populated that means we are working with a small result
+    # set.
+    if (
+        warn_on_large_results
+        and (table_ref := getattr(results, "_table", None)) is not None
+    ):
+        table = bqclient.get_table(table_ref)
+        if (
+            isinstance((num_bytes := table.num_bytes), int)
+            and num_bytes > pandas_gbq.constants.BYTES_TO_RECOMMEND_BIGFRAMES
+        ):
+            num_gib = num_bytes / pandas_gbq.constants.BYTES_IN_GIB
+            warnings.warn(
+                f"Recommendation: Your results are {num_gib:.1f} GiB. "
+                "Consider using BigQuery DataFrames (https://bit.ly/bigframes-intro)"
+                "to process large results with pandas compatible APIs with transparent SQL "
+                "pushdown to BigQuery engine. This provides an opportunity to save on costs "
+                "and improve performance. "
+                "Please reach out to bigframes-feedback@google.com with any "
+                "questions or concerns. To disable this message, run "
+                "warnings.simplefilter('ignore', category=pandas_gbq.exceptions.LargeResultsWarning)",
+                category=pandas_gbq.exceptions.LargeResultsWarning,
+                # user's code
+                # -> read_gbq
+                # -> run_query
+                # -> download_results
+                stacklevel=4,
+            )
+
+    try:
+        schema_fields = [field.to_api_repr() for field in results.schema]
+        conversion_dtypes = _bqschema_to_nullsafe_dtypes(schema_fields)
+        conversion_dtypes.update(user_dtypes)
+        df = results.to_dataframe(
+            dtypes=conversion_dtypes,
+            progress_bar_type=progress_bar_type,
+            create_bqstorage_client=create_bqstorage_client,
+        )
+    except pandas_gbq.constants.HTTP_ERRORS as ex:
+        raise pandas_gbq.exceptions.translate_exception(ex) from ex
+
+    df = _finalize_dtypes(df, schema_fields)
+
+    pandas_gbq.logger.debug("Got {} rows.\n".format(results.total_rows))
+    return df
diff --git a/packages/pandas-gbq/pandas_gbq/core/sample.py b/packages/pandas-gbq/pandas_gbq/core/sample.py
new file mode 100644
index 000000000000..49eee4b57ed2
--- /dev/null
+++ b/packages/pandas-gbq/pandas_gbq/core/sample.py
@@ -0,0 +1,323 @@
+# Copyright (c) 2025 pandas-gbq Authors All rights reserved.
+# Use of this source code is governed by a BSD-style
+# license that can be found in the LICENSE file.
+
+from __future__ import annotations
+
+import typing
+from typing import Optional, Sequence, cast
+
+import google.cloud.bigquery
+import google.cloud.bigquery.table
+import google.oauth2.credentials
+import psutil
+
+import pandas_gbq.constants
+import pandas_gbq.core.read
+import pandas_gbq.gbq_connector
+
+# Only import at module-level at type checking time to avoid circular
+# dependencies in the pandas package, which has an optional dependency on
+# pandas-gbq.
+if typing.TYPE_CHECKING:  # pragma: NO COVER
+    import pandas
+
+
+_READ_API_ELIGIBLE_TYPES = ("TABLE", "MATERIALIZED_VIEW", "EXTERNAL")
+_TABLESAMPLE_ELIGIBLE_TYPES = ("TABLE", "EXTERNAL")
+
+# Base logical sizes for non-complex and non-variable types.
+# https://docs.cloud.google.com/bigquery/docs/reference/standard-sql/data-types#data_type_sizes
+_TYPE_SIZES = {
+    # Fixed size types
+    "BOOL": 1,
+    "DATE": 8,
+    "DATETIME": 8,
+    "FLOAT64": 8,
+    "INT64": 8,
+    "TIME": 8,
+    "TIMESTAMP": 8,
+    "INTERVAL": 16,
+    "NUMERIC": 16,
+    "RANGE": 16,
+    "BIGNUMERIC": 32,
+    # Variable types with a fixed-size assumption
+    "STRING": pandas_gbq.constants.BYTES_IN_KIB,
+    "JSON": pandas_gbq.constants.BYTES_IN_KIB,
+    "BYTES": pandas_gbq.constants.BYTES_IN_MIB,
+    # Formula: 16 logical bytes + 24 logical bytes * num_vertices
+    # Assuming a small, fixed number of vertices (e.g., 5) for estimation:
+    "GEOGRAPHY": 16 + (24 * 5),
+}
+# TODO(tswast): Choose an estimate based on actual BigQuery stats.
+_ARRAY_LENGTH_ESTIMATE = 5
+_UNKNOWN_TYPE_SIZE_ESTIMATE = 4
+_MAX_ROW_BYTES = 100 * pandas_gbq.constants.BYTES_IN_MIB
+_MAX_AUTO_TARGET_BYTES = 1 * pandas_gbq.constants.BYTES_IN_GIB
+
+
+def _calculate_target_bytes(target_mb: Optional[int]) -> int:
+    if target_mb is not None:
+        return target_mb * pandas_gbq.constants.BYTES_IN_MIB
+
+    mem = psutil.virtual_memory()
+    return min(_MAX_AUTO_TARGET_BYTES, max(_MAX_ROW_BYTES, mem.available // 4))
+
+
+def _estimate_limit(
+    *,
+    target_bytes: int,
+    table_bytes: Optional[int],
+    table_rows: Optional[int],
+    fields: Sequence[google.cloud.bigquery.SchemaField],
+) -> int:
+    if table_bytes and table_rows:
+        proportion = target_bytes / table_bytes
+        return max(1, int(table_rows * proportion))
+
+    row_bytes_estimate = _estimate_row_bytes(fields)
+    assert row_bytes_estimate >= 0
+
+    if row_bytes_estimate == 0:
+        # Assume there's some overhead per row so we have some kind of limit.
+        return target_bytes
+
+    return max(1, target_bytes // row_bytes_estimate)
+
+
+def _estimate_field_bytes(field: google.cloud.bigquery.SchemaField) -> int:
+    """Recursive helper function to calculate the size of a single field."""
+    field_type = field.field_type
+
+    # If the field is REPEATED (ARRAY), its size is the sum of its elements.
+    if field.mode == "REPEATED":
+        # Create a temporary single-element field for size calculation
+        temp_field = google.cloud.bigquery.SchemaField(
+            field.name, field.field_type, mode="NULLABLE", fields=field.fields
+        )
+        element_size = _estimate_field_bytes(temp_field)
+        return _ARRAY_LENGTH_ESTIMATE * element_size
+
+    if field_type == "STRUCT" or field_type == "RECORD":
+        # STRUCT has 0 logical bytes + the size of its contained fields.
+        return _estimate_row_bytes(field.fields)
+
+    return _TYPE_SIZES.get(field_type.upper(), _UNKNOWN_TYPE_SIZE_ESTIMATE)
+
+
+def _estimate_row_bytes(fields: Sequence[google.cloud.bigquery.SchemaField]) -> int:
+    """
+    Estimates the logical row size in bytes for a list of BigQuery SchemaField objects,
+    using the provided data type size chart and assuming 1MB for all STRING and BYTES
+    fields.
+
+    Args:
+        schema_fields: A list of google.cloud.bigquery.SchemaField objects
+                       representing the table schema.
+
+    Returns:
+        An integer representing the estimated total row size in logical bytes.
+    """
+    total_size = min(
+        _MAX_ROW_BYTES,
+        sum(_estimate_field_bytes(field) for field in fields),
+    )
+    return total_size
+
+
+def _download_results_in_parallel(
+    rows: google.cloud.bigquery.table.RowIterator,
+    *,
+    bqclient: google.cloud.bigquery.Client,
+    progress_bar_type: Optional[str] = None,
+    use_bqstorage_api: bool = True,
+):
+    table_reference = getattr(rows, "_table", None)
+    schema = getattr(rows, "_schema", None)
+
+    # If the results are large enough to materialize a table, break the
+    # connection to the original query that contains an ORDER BY clause to allow
+    # reading with multiple streams.
+    if table_reference is not None and schema is not None:
+        rows = bqclient.list_rows(
+            table_reference,
+            selected_fields=schema,
+        )
+
+    return pandas_gbq.core.read.download_results(
+        rows,
+        bqclient=bqclient,
+        progress_bar_type=progress_bar_type,
+        warn_on_large_results=False,
+        max_results=None,
+        user_dtypes=None,
+        use_bqstorage_api=use_bqstorage_api,
+    )
+
+
+def _sample_with_tablesample(
+    table: google.cloud.bigquery.Table,
+    *,
+    bqclient: google.cloud.bigquery.Client,
+    proportion: float,
+    target_row_count: int,
+    progress_bar_type: Optional[str] = None,
+    use_bqstorage_api: bool = True,
+) -> Optional[pandas.DataFrame]:
+    query = f"""
+    SELECT *
+    FROM `{table.project}.{table.dataset_id}.{table.table_id}`
+    TABLESAMPLE SYSTEM ({float(proportion) * 100.0} PERCENT)
+    ORDER BY RAND() DESC
+    LIMIT {int(target_row_count)};
+    """
+    rows = bqclient.query_and_wait(query)
+    return _download_results_in_parallel(
+        rows,
+        bqclient=bqclient,
+        progress_bar_type=progress_bar_type,
+        use_bqstorage_api=use_bqstorage_api,
+    )
+
+
+def _sample_with_limit(
+    table: google.cloud.bigquery.Table,
+    *,
+    bqclient: google.cloud.bigquery.Client,
+    target_row_count: int,
+    progress_bar_type: Optional[str] = None,
+    use_bqstorage_api: bool = True,
+) -> Optional[pandas.DataFrame]:
+    query = f"""
+    SELECT *
+    FROM `{table.project}.{table.dataset_id}.{table.table_id}`
+    ORDER BY RAND() DESC
+    LIMIT {int(target_row_count)};
+    """
+    rows = bqclient.query_and_wait(query)
+    return _download_results_in_parallel(
+        rows,
+        bqclient=bqclient,
+        progress_bar_type=progress_bar_type,
+        use_bqstorage_api=use_bqstorage_api,
+    )
+
+
+def sample(
+    table_id: str,
+    *,
+    target_mb: Optional[int] = None,
+    credentials: Optional[google.oauth2.credentials.Credentials] = None,
+    billing_project_id: Optional[str] = None,
+    progress_bar_type: Optional[str] = None,
+    use_bqstorage_api: bool = True,
+) -> Optional[pandas.DataFrame]:
+    """Sample a BigQuery table, attempting to limit the amount of data read.
+
+    This function attempts to sample a BigQuery table to a target size in
+    memory. It prioritizes methods that minimize data scanned and downloaded.
+
+    The target size is based on an estimate of the row size and this method
+    return more or less than expected. If the table metadata doesn't include
+    a size, such as with views, an estimate based on the table schema is
+    used.
+
+    Sampling is based on the `BigQuery TABLESAMPLE
+    <https://docs.cloud.google.com/bigquery/docs/table-sampling>`_ feature,
+    which can provide a biased sample if data is not randomly distributed
+    among file blocks. For more control over sampling, use BigQuery
+    DataFrames ``read_gbq_table`` and ``DataFrame.sample`` methods.
+
+    Specificially, the sampling strategy is as follows:
+
+    1. If the table is small enough (based on `target_mb` or available memory)
+       and eligible for the BigQuery Storage Read API, the entire table is
+       downloaded.
+    2. If the table is larger than the target size and eligible for
+       `TABLESAMPLE SYSTEM` (e.g., a regular table), a `TABLESAMPLE` query
+       is used to retrieve a proportion of rows, followed by `ORDER BY RAND()`
+       and `LIMIT` to get the `target_row_count`.
+    3. If `TABLESAMPLE` is not applicable (e.g., for views) or `num_bytes` is
+       not available, a full table scan is performed with `ORDER BY RAND()`
+       and `LIMIT` to retrieve the `target_row_count`.
+
+    Args:
+        table_id: The BigQuery table ID to sample, in the format
+            "project.dataset.table" or "dataset.table".
+        target_mb: Optional. The target size in megabytes for the sampled
+            DataFrame. If not specified, it defaults to 1/4 of available
+            system memory, with a minimum of 100MB and maximum of 1 GB.
+        credentials: Optional. The credentials to use for BigQuery access.
+            If not provided, `pandas_gbq` will attempt to infer them.
+        billing_project_id: Optional. The ID of the Google Cloud project to
+            bill for the BigQuery job. If not provided, `pandas_gbq` will
+            attempt to infer it.
+        progress_bar_type: Optional. Type of progress bar to display.
+            See `pandas_gbq.core.read.download_results` for options.
+        use_bqstorage_api: Optional. If `True`, use the BigQuery Storage Read
+            API for faster downloads. Defaults to `True`.
+
+    Returns:
+        A `pandas.DataFrame` containing the sampled data, or `None` if no data
+        could be sampled.
+    """
+    target_bytes = _calculate_target_bytes(target_mb)
+    connector = pandas_gbq.gbq_connector.GbqConnector(
+        project_id=billing_project_id, credentials=credentials
+    )
+    credentials = cast(google.oauth2.credentials.Credentials, connector.credentials)
+    bqclient = connector.get_client()
+    table = bqclient.get_table(table_id)
+    num_rows = table.num_rows
+    num_bytes = table.num_bytes
+    table_type = table.table_type
+
+    # Some tables such as views report 0 despite actually having rows.
+    if num_bytes == 0:
+        num_bytes = None
+
+    # Table is small enough to download the whole thing.
+    if (
+        table_type in _READ_API_ELIGIBLE_TYPES
+        and num_bytes is not None
+        and num_bytes <= target_bytes
+    ):
+        rows_iter = bqclient.list_rows(table)
+        return pandas_gbq.core.read.download_results(
+            rows_iter,
+            bqclient=bqclient,
+            progress_bar_type=progress_bar_type,
+            warn_on_large_results=False,
+            max_results=None,
+            user_dtypes=None,
+            use_bqstorage_api=use_bqstorage_api,
+        )
+
+    target_row_count = _estimate_limit(
+        target_bytes=target_bytes,
+        table_bytes=num_bytes,
+        table_rows=num_rows,
+        fields=table.schema,
+    )
+
+    # Table is eligible for TABLESAMPLE.
+    if num_bytes is not None and table_type in _TABLESAMPLE_ELIGIBLE_TYPES:
+        proportion = target_bytes / num_bytes
+        return _sample_with_tablesample(
+            table,
+            bqclient=bqclient,
+            proportion=proportion,
+            target_row_count=target_row_count,
+            progress_bar_type=progress_bar_type,
+            use_bqstorage_api=use_bqstorage_api,
+        )
+
+    # Not eligible for TABLESAMPLE or reading directly, so take a random sample
+    # with a full table scan.
+    return _sample_with_limit(
+        table,
+        bqclient=bqclient,
+        target_row_count=target_row_count,
+        progress_bar_type=progress_bar_type,
+        use_bqstorage_api=use_bqstorage_api,
+    )
diff --git a/packages/pandas-gbq/pandas_gbq/environment.py b/packages/pandas-gbq/pandas_gbq/environment.py
new file mode 100644
index 000000000000..bf2c6d76bb77
--- /dev/null
+++ b/packages/pandas-gbq/pandas_gbq/environment.py
@@ -0,0 +1,99 @@
+# Copyright (c) 2025 pandas-gbq Authors All rights reserved.
+# Use of this source code is governed by a BSD-style
+# license that can be found in the LICENSE file.
+
+
+import importlib
+import json
+import os
+import pathlib
+
+Path = pathlib.Path
+
+
+# The identifier for GCP VS Code extension
+# https://cloud.google.com/code/docs/vscode/install
+GOOGLE_CLOUD_CODE_EXTENSION_NAME = "googlecloudtools.cloudcode"
+
+
+# The identifier for BigQuery Jupyter notebook plugin
+# https://cloud.google.com/bigquery/docs/jupyterlab-plugin
+BIGQUERY_JUPYTER_PLUGIN_NAME = "bigquery_jupyter_plugin"
+
+
+def _is_vscode_extension_installed(extension_id: str) -> bool:
+    """
+    Checks if a given Visual Studio Code extension is installed.
+
+    Args:
+        extension_id: The ID of the extension (e.g., "ms-python.python").
+
+    Returns:
+        True if the extension is installed, False otherwise.
+    """
+    try:
+        # Determine the user's VS Code extensions directory.
+        user_home = Path.home()
+        vscode_extensions_dir = user_home / ".vscode" / "extensions"
+
+        # Check if the extensions directory exists.
+        if not vscode_extensions_dir.exists():
+            return False
+
+        # Iterate through the subdirectories in the extensions directory.
+        for item in vscode_extensions_dir.iterdir():
+            # Ignore non-directories.
+            if not item.is_dir():
+                continue
+
+            # Directory must start with the extension ID.
+            if not item.name.startswith(extension_id + "-"):
+                continue
+
+            # As a more robust check, the manifest file must exist.
+            manifest_path = item / "package.json"
+            if not manifest_path.exists() or not manifest_path.is_file():
+                continue
+
+            # Finally, the manifest file must be a valid json
+            with open(manifest_path, "r", encoding="utf-8") as f:
+                json.load(f)
+
+            return True
+    except Exception:
+        pass
+
+    return False
+
+
+def _is_package_installed(package_name: str) -> bool:
+    """
+    Checks if a Python package is installed.
+
+    Args:
+        package_name: The name of the package to check (e.g., "requests", "numpy").
+
+    Returns:
+        True if the package is installed, False otherwise.
+    """
+    try:
+        importlib.import_module(package_name)
+        return True
+    except Exception:
+        return False
+
+
+def is_vscode() -> bool:
+    return os.getenv("VSCODE_PID") is not None
+
+
+def is_jupyter() -> bool:
+    return os.getenv("JPY_PARENT_PID") is not None
+
+
+def is_vscode_google_cloud_code_extension_installed() -> bool:
+    return _is_vscode_extension_installed(GOOGLE_CLOUD_CODE_EXTENSION_NAME)
+
+
+def is_jupyter_bigquery_plugin_installed() -> bool:
+    return _is_package_installed(BIGQUERY_JUPYTER_PLUGIN_NAME)
diff --git a/packages/pandas-gbq/pandas_gbq/exceptions.py b/packages/pandas-gbq/pandas_gbq/exceptions.py
new file mode 100644
index 000000000000..ab5f05b46a79
--- /dev/null
+++ b/packages/pandas-gbq/pandas_gbq/exceptions.py
@@ -0,0 +1,133 @@
+# Copyright (c) 2017 pandas-gbq Authors All rights reserved.
+# Use of this source code is governed by a BSD-style
+# license that can be found in the LICENSE file.
+
+
+class DatasetCreationError(ValueError):
+    """
+    Raised when the create dataset method fails
+    """
+
+
+class InvalidColumnOrder(ValueError):
+    """
+    Raised when the provided column order for output
+    results DataFrame does not match the schema
+    returned by BigQuery.
+    """
+
+
+class InvalidIndexColumn(ValueError):
+    """
+    Raised when the provided index column for output
+    results DataFrame does not match the schema
+    returned by BigQuery.
+    """
+
+
+class InvalidPageToken(ValueError):
+    """
+    Raised when Google BigQuery fails to return,
+    or returns a duplicate page token.
+    """
+
+
+class InvalidSchema(ValueError):
+    """
+    Raised when the provided DataFrame does
+    not match the schema of the destination
+    table in BigQuery.
+    """
+
+    def __init__(self, message: str):
+        self._message = message
+
+    @property
+    def message(self) -> str:
+        return self._message
+
+
+class NotFoundException(ValueError):
+    """
+    Raised when the project_id, table or dataset provided in the query could
+    not be found.
+    """
+
+
+class TableCreationError(ValueError):
+    """
+    Raised when the create table method fails
+    """
+
+    def __init__(self, message: str):
+        self._message = message
+
+    @property
+    def message(self) -> str:
+        return self._message
+
+
+class GenericGBQException(ValueError):
+    """
+    Raised when an unrecognized Google API Error occurs.
+    """
+
+
+class AccessDenied(ValueError):
+    """
+    Raised when invalid credentials are provided, or tokens have expired.
+    """
+
+
+class ConversionError(GenericGBQException):
+    """
+    Raised when there is a problem converting the DataFrame to a format
+    required to upload it to BigQuery.
+    """
+
+
+class InvalidPrivateKeyFormat(ValueError):
+    """
+    Raised when provided private key has invalid format.
+    """
+
+
+class LargeResultsWarning(UserWarning):
+    """Raise when results are beyond that recommended for pandas DataFrame."""
+
+
+class PerformanceWarning(RuntimeWarning):
+    """
+    Raised when a performance-related feature is requested, but unsupported.
+
+    Such warnings can occur when dependencies for the requested feature
+    aren't up-to-date.
+    """
+
+
+class QueryTimeout(ValueError):
+    """
+    Raised when the query request exceeds the timeoutMs value specified in the
+    BigQuery configuration.
+    """
+
+
+def translate_exception(ex):
+    # See `BigQuery Troubleshooting Errors
+    # <https://cloud.google.com/bigquery/troubleshooting-errors>`__
+
+    message = (
+        ex.message.casefold()
+        if hasattr(ex, "message") and ex.message is not None
+        else ""
+    )
+    if "cancelled" in message:
+        return QueryTimeout("Reason: {0}".format(ex))
+    elif "schema does not match" in message:
+        error_message = ex.errors[0]["message"]
+        return InvalidSchema(f"Reason: {error_message}")
+    elif "already exists: table" in message:
+        error_message = ex.errors[0]["message"]
+        return TableCreationError(f"Reason: {error_message}")
+    else:
+        return GenericGBQException("Reason: {0}".format(ex))
diff --git a/packages/pandas-gbq/pandas_gbq/features.py b/packages/pandas-gbq/pandas_gbq/features.py
new file mode 100644
index 000000000000..62405b4c1f9e
--- /dev/null
+++ b/packages/pandas-gbq/pandas_gbq/features.py
@@ -0,0 +1,85 @@
+# Copyright (c) 2017 pandas-gbq Authors All rights reserved.
+# Use of this source code is governed by a BSD-style
+# license that can be found in the LICENSE file.
+
+"""Module for checking dependency versions and supported features."""
+
+# https://github.com/googleapis/python-bigquery/blob/main/CHANGELOG.md
+BIGQUERY_MINIMUM_VERSION = "3.4.2"
+BIGQUERY_QUERY_AND_WAIT_VERSION = "3.14.0"
+PANDAS_VERBOSITY_DEPRECATION_VERSION = "0.23.0"
+PANDAS_BOOLEAN_DTYPE_VERSION = "1.0.0"
+
+
+class Features:
+    def __init__(self):
+        self._bigquery_installed_version = None
+        self._pandas_installed_version = None
+
+    @property
+    def bigquery_installed_version(self):
+        import google.cloud.bigquery
+        import packaging.version
+
+        if self._bigquery_installed_version is not None:
+            return self._bigquery_installed_version
+
+        self._bigquery_installed_version = packaging.version.parse(
+            google.cloud.bigquery.__version__
+        )
+        return self._bigquery_installed_version
+
+    def bigquery_try_import(self):
+        import google.cloud.bigquery
+        import packaging.version
+
+        bigquery_minimum_version = packaging.version.parse(BIGQUERY_MINIMUM_VERSION)
+
+        if self.bigquery_installed_version < bigquery_minimum_version:
+            raise ImportError(
+                "pandas-gbq requires google-cloud-bigquery >= {0}, "
+                "current version {1}".format(
+                    bigquery_minimum_version, self._bigquery_installed_version
+                )
+            )
+
+        return google.cloud.bigquery
+
+    @property
+    def bigquery_has_query_and_wait(self):
+        import packaging.version
+
+        min_version = packaging.version.parse(BIGQUERY_QUERY_AND_WAIT_VERSION)
+        return self.bigquery_installed_version >= min_version
+
+    @property
+    def pandas_installed_version(self):
+        import packaging.version
+        import pandas
+
+        if self._pandas_installed_version is not None:
+            return self._pandas_installed_version
+
+        self._pandas_installed_version = packaging.version.parse(pandas.__version__)
+        return self._pandas_installed_version
+
+    @property
+    def pandas_has_deprecated_verbose(self):
+        import packaging.version
+
+        # Add check for Pandas version before showing deprecation warning.
+        # https://github.com/pydata/pandas-gbq/issues/157
+        pandas_verbosity_deprecation = packaging.version.parse(
+            PANDAS_VERBOSITY_DEPRECATION_VERSION
+        )
+        return self.pandas_installed_version >= pandas_verbosity_deprecation
+
+    @property
+    def pandas_has_boolean_dtype(self):
+        import packaging.version
+
+        desired_version = packaging.version.parse(PANDAS_BOOLEAN_DTYPE_VERSION)
+        return self.pandas_installed_version >= desired_version
+
+
+FEATURES = Features()
diff --git a/packages/pandas-gbq/pandas_gbq/gbq.py b/packages/pandas-gbq/pandas_gbq/gbq.py
new file mode 100644
index 000000000000..dcc96d49b2d2
--- /dev/null
+++ b/packages/pandas-gbq/pandas_gbq/gbq.py
@@ -0,0 +1,935 @@
+# Copyright (c) 2017 pandas-gbq Authors All rights reserved.
+# Use of this source code is governed by a BSD-style
+# license that can be found in the LICENSE file.
+
+import copy
+from datetime import datetime
+import logging
+import re
+import typing
+import warnings
+
+import pandas
+
+from pandas_gbq.contexts import Context  # noqa - backward compatible export
+from pandas_gbq.contexts import context
+from pandas_gbq.exceptions import (  # noqa - backward compatible export
+    DatasetCreationError,
+    GenericGBQException,
+    InvalidColumnOrder,
+    InvalidIndexColumn,
+    NotFoundException,
+    TableCreationError,
+)
+from pandas_gbq.exceptions import InvalidPageToken  # noqa - backward compatible export
+from pandas_gbq.exceptions import InvalidSchema  # noqa - backward compatible export
+from pandas_gbq.exceptions import QueryTimeout  # noqa - backward compatible export
+from pandas_gbq.features import FEATURES
+from pandas_gbq.gbq_connector import GbqConnector  # noqa - backward compatible export
+from pandas_gbq.gbq_connector import _get_client  # noqa - backward compatible export
+import pandas_gbq.schema
+import pandas_gbq.schema.pandas_to_bigquery
+
+logger = logging.getLogger(__name__)
+
+
+def _test_google_api_imports():
+    try:
+        import packaging  # noqa
+    except ImportError as ex:  # pragma: NO COVER
+        raise ImportError("pandas-gbq requires db-dtypes") from ex
+
+    try:
+        import db_dtypes  # noqa
+    except ImportError as ex:  # pragma: NO COVER
+        raise ImportError("pandas-gbq requires db-dtypes") from ex
+
+    try:
+        import pydata_google_auth  # noqa
+    except ImportError as ex:  # pragma: NO COVER
+        raise ImportError("pandas-gbq requires pydata-google-auth") from ex
+
+    try:
+        from google_auth_oauthlib.flow import InstalledAppFlow  # noqa
+    except ImportError as ex:  # pragma: NO COVER
+        raise ImportError("pandas-gbq requires google-auth-oauthlib") from ex
+
+    try:
+        import google.auth  # noqa
+    except ImportError as ex:  # pragma: NO COVER
+        raise ImportError("pandas-gbq requires google-auth") from ex
+
+    try:
+        from google.cloud import bigquery  # noqa
+    except ImportError as ex:  # pragma: NO COVER
+        raise ImportError("pandas-gbq requires google-cloud-bigquery") from ex
+
+
+def _is_query(query_or_table: str) -> bool:
+    return re.search(r"\s", query_or_table.strip(), re.MULTILINE) is not None
+
+
+def _transform_read_gbq_configuration(configuration):
+    """
+    For backwards-compatibility, convert any previously client-side only
+    parameters such as timeoutMs to the property name expected by the REST API.
+
+    Makes a copy of configuration if changes are needed.
+    """
+
+    if configuration is None:
+        return None
+
+    timeout_ms = configuration.get("query", {}).get("timeoutMs")
+    if timeout_ms is not None:
+        # Transform timeoutMs to an actual server-side configuration.
+        # https://github.com/googleapis/python-bigquery-pandas/issues/479
+        configuration = copy.deepcopy(configuration)
+        del configuration["query"]["timeoutMs"]
+        configuration["jobTimeoutMs"] = timeout_ms
+
+    return configuration
+
+
+def read_gbq(
+    query_or_table,
+    project_id=None,
+    index_col=None,
+    columns=None,
+    reauth=False,
+    auth_local_webserver=True,
+    dialect=None,
+    location=None,
+    configuration=None,
+    credentials=None,
+    use_bqstorage_api=False,
+    max_results=None,
+    verbose=None,
+    private_key=None,
+    progress_bar_type="tqdm",
+    dtypes=None,
+    auth_redirect_uri=None,
+    client_id=None,
+    client_secret=None,
+    *,
+    col_order=None,
+    bigquery_client=None,
+):
+    r"""Read data from Google BigQuery to a pandas DataFrame.
+
+    Run a SQL query in BigQuery or read directly from a table
+    the `Python client library for BigQuery
+    <https://cloud.google.com/python/docs/reference/bigquery/latest/index.html>`__
+    and for `BigQuery Storage
+    <https://cloud.google.com/python/docs/reference/bigquerystorage/latest>`__
+    to make API requests.
+
+    See the :ref:`How to authenticate with Google BigQuery <authentication>`
+    guide for authentication instructions.
+
+    .. note::
+        Consider using `BigQuery DataFrames
+        <https://cloud.google.com/bigquery/docs/dataframes-quickstart>`__ to
+        process large results with pandas compatible APIs that run in the
+        BigQuery SQL query engine. This provides an opportunity to save on
+        costs and improve performance.
+
+    Parameters
+    ----------
+    query_or_table : str
+        SQL query to return data values. If the string is a table ID, fetch the
+        rows directly from the table without running a query.
+    project_id : str, optional
+        Google Cloud Platform project ID. Optional when available from
+        the environment.
+    index_col : str, optional
+        Name of result column to use for index in results DataFrame.
+    columns : list(str), optional
+        List of BigQuery column names in the desired order for results
+        DataFrame.
+    reauth : boolean, default False
+        Force Google BigQuery to re-authenticate the user. This is useful
+        if multiple accounts are used.
+    auth_local_webserver : bool, default True
+        Use the `local webserver flow
+        <https://googleapis.dev/python/google-auth-oauthlib/latest/reference/google_auth_oauthlib.flow.html#google_auth_oauthlib.flow.InstalledAppFlow.run_local_server>`_
+        instead of the `console flow
+        <https://googleapis.dev/python/google-auth-oauthlib/latest/reference/google_auth_oauthlib.flow.html#google_auth_oauthlib.flow.InstalledAppFlow.run_console>`_
+        when getting user credentials. Your code must run on the same machine
+        as your web browser and your web browser can access your application
+        via ``localhost:808X``.
+
+        .. versionadded:: 0.2.0
+    dialect : str, default 'standard'
+        Note: The default value changed to 'standard' in version 0.10.0.
+
+        SQL syntax dialect to use. Value can be one of:
+
+        ``'legacy'``
+            Use BigQuery's legacy SQL dialect. For more information see
+            `BigQuery Legacy SQL Reference
+            <https://cloud.google.com/bigquery/docs/reference/legacy-sql>`__.
+        ``'standard'``
+            Use BigQuery's standard SQL, which is
+            compliant with the SQL 2011 standard. For more information
+            see `BigQuery Standard SQL Reference
+            <https://cloud.google.com/bigquery/docs/reference/standard-sql/>`__.
+    location : str, optional
+        Location where the query job should run. See the `BigQuery locations
+        documentation
+        <https://cloud.google.com/bigquery/docs/dataset-locations>`__ for a
+        list of available locations. The location must match that of any
+        datasets used in the query.
+
+        .. versionadded:: 0.5.0
+    configuration : dict, optional
+        Query config parameters for job processing.
+        For example:
+
+            configuration = {'query': {'useQueryCache': False}}
+
+        For more information see `BigQuery REST API Reference
+        <https://cloud.google.com/bigquery/docs/reference/rest/v2/jobs#configuration.query>`__.
+    credentials : google.auth.credentials.Credentials, optional
+        Credentials for accessing Google APIs. Use this parameter to override
+        default credentials, such as to use Compute Engine
+        :class:`google.auth.compute_engine.Credentials` or Service Account
+        :class:`google.oauth2.service_account.Credentials` directly.
+
+        .. versionadded:: 0.8.0
+    use_bqstorage_api : bool, default False
+        Use the `BigQuery Storage API
+        <https://cloud.google.com/bigquery/docs/reference/storage/>`__ to
+        download query results quickly, but at an increased cost. To use this
+        API, first `enable it in the Cloud Console
+        <https://console.cloud.google.com/apis/library/bigquerystorage.googleapis.com>`__.
+        You must also have the `bigquery.readsessions.create
+        <https://cloud.google.com/bigquery/docs/access-control#roles>`__
+        permission on the project you are billing queries to.
+
+        This feature requires the ``google-cloud-bigquery-storage`` and
+        ``pyarrow`` packages.
+
+        This value is ignored if ``max_results`` is set.
+
+        .. versionadded:: 0.10.0
+    max_results : int, optional
+        If set, limit the maximum number of rows to fetch from the query
+        results.
+
+        .. versionadded:: 0.12.0
+    progress_bar_type (Optional[str]):
+        If set, use the `tqdm <https://tqdm.github.io/>`__ library to
+        display a progress bar while the data downloads. Install the
+        ``tqdm`` package to use this feature.
+        Possible values of ``progress_bar_type`` include:
+
+        ``None``
+            No progress bar.
+        ``'tqdm'``
+            Use the :func:`tqdm.tqdm` function to print a progress bar
+            to :data:`sys.stderr`.
+        ``'tqdm_notebook'``
+            Use the :func:`tqdm.tqdm_notebook` function to display a
+            progress bar as a Jupyter notebook widget.
+        ``'tqdm_gui'``
+            Use the :func:`tqdm.tqdm_gui` function to display a
+            progress bar as a graphical dialog box.
+    dtypes : dict, optional
+        A dictionary of column names to pandas ``dtype``. The provided
+        ``dtype`` is used when constructing the series for the column
+        specified. Otherwise, a default ``dtype`` is used.
+    verbose : None, deprecated
+        Deprecated in Pandas-GBQ 0.4.0. Use the `logging module
+        to adjust verbosity instead
+        <https://pandas-gbq.readthedocs.io/en/latest/intro.html#logging>`__.
+    private_key : str, deprecated
+        Deprecated in pandas-gbq version 0.8.0. Use the ``credentials``
+        parameter and
+        :func:`google.oauth2.service_account.Credentials.from_service_account_info`
+        or
+        :func:`google.oauth2.service_account.Credentials.from_service_account_file`
+        instead.
+    auth_redirect_uri : str
+        Path to the authentication page for organization-specific authentication
+        workflows. Used when ``auth_local_webserver=False``.
+    client_id : str
+        The Client ID for the Google Cloud Project the user is attempting to
+        connect to.
+    client_secret : str
+        The Client Secret associated with the Client ID for the Google Cloud Project
+        the user is attempting to connect to.
+    col_order : list(str), optional
+        Alias for columns, retained for backwards compatibility.
+    bigquery_client : google.cloud.bigquery.Client, optional
+        A Google Cloud BigQuery Python Client instance. If provided, it will be used for reading
+        data, while the project and credentials parameters will be ignored.
+
+    Returns
+    -------
+    df: DataFrame
+        DataFrame representing results of query.
+    """
+    if dialect is None:
+        dialect = context.dialect
+
+    if dialect is None:
+        dialect = "standard"
+
+    _test_google_api_imports()
+
+    if verbose is not None and FEATURES.pandas_has_deprecated_verbose:
+        warnings.warn(
+            "verbose is deprecated and will be removed in "
+            "a future version. Set logging level in order to vary "
+            "verbosity",
+            FutureWarning,
+            stacklevel=2,
+        )
+
+    if dialect not in ("legacy", "standard"):
+        raise ValueError("'{0}' is not valid for dialect".format(dialect))
+
+    configuration = _transform_read_gbq_configuration(configuration)
+
+    if configuration and "query" in configuration and "query" in configuration["query"]:
+        if query_or_table is not None:
+            raise ValueError(
+                "Query statement can't be specified "
+                "inside config while it is specified "
+                "as parameter"
+            )
+        query_or_table = configuration["query"].pop("query")
+
+    connector = GbqConnector(
+        project_id,
+        reauth=reauth,
+        dialect=dialect,
+        auth_local_webserver=auth_local_webserver,
+        location=location,
+        credentials=credentials,
+        private_key=private_key,
+        use_bqstorage_api=use_bqstorage_api,
+        auth_redirect_uri=auth_redirect_uri,
+        client_id=client_id,
+        client_secret=client_secret,
+        bigquery_client=bigquery_client,
+    )
+
+    if _is_query(query_or_table):
+        final_df = connector.run_query(
+            query_or_table,
+            configuration=configuration,
+            max_results=max_results,
+            progress_bar_type=progress_bar_type,
+            dtypes=dtypes,
+        )
+    else:
+        final_df = connector.download_table(
+            query_or_table,
+            max_results=max_results,
+            progress_bar_type=progress_bar_type,
+            dtypes=dtypes,
+        )
+
+    # Reindex the DataFrame on the provided column
+    if index_col is not None:
+        if index_col in final_df.columns:
+            final_df.set_index(index_col, inplace=True)
+        else:
+            raise InvalidIndexColumn(
+                'Index column "{0}" does not exist in DataFrame.'.format(index_col)
+            )
+
+    # Using columns as an alias for col_order, raising an error if both provided
+    if col_order and not columns:
+        columns = col_order
+    elif col_order and columns:
+        raise ValueError(
+            "Must specify either columns (preferred) or col_order, not both"
+        )
+
+    # Change the order of columns in the DataFrame based on provided list
+    # TODO(kiraksi): allow columns to be a subset of all columns in the table, with follow up PR
+    if columns is not None:
+        if sorted(columns) == sorted(final_df.columns):
+            final_df = final_df[columns]
+        else:
+            raise InvalidColumnOrder("Column order does not match this DataFrame.")
+
+    connector.log_elapsed_seconds(
+        "Total time taken",
+        datetime.now().strftime("s.\nFinished at %Y-%m-%d %H:%M:%S."),
+    )
+
+    return final_df
+
+
+def to_gbq(
+    dataframe,
+    destination_table,
+    project_id=None,
+    chunksize=None,
+    reauth=False,
+    if_exists="fail",
+    auth_local_webserver=True,
+    table_schema=None,
+    location=None,
+    progress_bar=True,
+    credentials=None,
+    api_method: str = "default",
+    clustering_columns: typing.Union[
+        pandas.core.indexes.base.Index, typing.Iterable[typing.Hashable]
+    ] = (),
+    time_partitioning_column: typing.Optional[str] = None,
+    time_partitioning_type: typing.Optional[str] = "DAY",
+    time_partitioning_expiration_ms: typing.Optional[int] = None,
+    range_partitioning_column: typing.Optional[str] = None,
+    range_partitioning_range: typing.Optional[dict] = None,
+    verbose=None,
+    private_key=None,
+    auth_redirect_uri=None,
+    client_id=None,
+    client_secret=None,
+    user_agent=None,
+    rfc9110_delimiter=False,
+    bigquery_client=None,
+):
+    """Write a DataFrame to a Google BigQuery table.
+
+    The main method a user calls to export pandas DataFrame contents to Google BigQuery table.
+
+    This method uses the Google Cloud client library to make requests to Google BigQuery, documented `here
+    <https://googleapis.dev/python/bigquery/latest/index.html>`__.
+
+    See the :ref:`How to authenticate with Google BigQuery <authentication>`
+    guide for authentication instructions.
+
+    Parameters
+    ----------
+    dataframe : pandas.DataFrame
+        DataFrame to be written to a Google BigQuery table.
+    destination_table : str
+        Name of table to be written, in the form ``dataset.tablename`` or
+        ``project.dataset.tablename``.
+    clustering_columns : pandas.Index | Iterable[Hashable], optional
+        Specifies the columns for clustering in the BigQuery table.
+    time_partitioning_column : str, optional
+        Specifies the column for time-based partitioning in the BigQuery table.
+    time_partitioning_type : str, default 'DAY'
+        Specifies the type of time-based partitioning.
+    time_partitioning_expiration_ms : int, optional
+        Specifies the milliseconds for time-based partitioning expiration.
+    range_partitioning_column : str, optional
+        Specifies the column for range-based partitioning in the BigQuery table.
+    range_partitioning_range : dict, optional
+        Specifies the range for range-based partitioning.
+    project_id : str, optional
+        Google Cloud Platform project ID. Optional when available from
+        the environment.
+    chunksize : int, optional
+        Number of rows to be inserted in each chunk from the dataframe.
+        Set to ``None`` to load the whole dataframe at once.
+    reauth : bool, default False
+        Force Google BigQuery to re-authenticate the user. This is useful
+        if multiple accounts are used.
+    if_exists : str, default 'fail'
+        Behavior when the destination table exists. Value can be one of:
+
+        ``'fail'``
+            If table exists, do nothing.
+        ``'replace'``
+            If table exists, drop it, recreate it, and insert data.
+        ``'append'``
+            If table exists, insert data. Create if does not exist.
+    auth_local_webserver : bool, default True
+        Use the `local webserver flow
+        <https://googleapis.dev/python/google-auth-oauthlib/latest/reference/google_auth_oauthlib.flow.html#google_auth_oauthlib.flow.InstalledAppFlow.run_local_server>`_
+        instead of the `console flow
+        <https://googleapis.dev/python/google-auth-oauthlib/latest/reference/google_auth_oauthlib.flow.html#google_auth_oauthlib.flow.InstalledAppFlow.run_console>`_
+        when getting user credentials. Your code must run on the same machine
+        as your web browser and your web browser can access your application
+        via ``localhost:808X``.
+
+        .. versionadded:: 0.2.0
+    table_schema : list of dicts, optional
+        List of BigQuery table fields to which according DataFrame
+        columns conform to, e.g. ``[{'name': 'col1', 'type':
+        'STRING'},...]``.  The ``type`` values must be BigQuery type names.
+
+        - If ``table_schema`` is provided, it may contain all or a subset of
+          DataFrame columns. If a subset is provided, the rest will be
+          inferred from the DataFrame dtypes.  If ``table_schema`` contains
+          columns not in the DataFrame, they'll be ignored.
+        - If ``table_schema`` is **not** provided, it will be
+          generated according to dtypes of DataFrame columns. See
+          `Inferring the Table Schema
+          <https://pandas-gbq.readthedocs.io/en/latest/writing.html#writing-schema>`__.
+          for a description of the schema inference.
+
+        See `BigQuery API documentation on valid column names
+        <https://cloud.google.com/bigquery/docs/schemas#column_names`>__.
+
+        .. versionadded:: 0.3.1
+    location : str, optional
+        Location where the load job should run. See the `BigQuery locations
+        documentation
+        <https://cloud.google.com/bigquery/docs/dataset-locations>`__ for a
+        list of available locations. The location must match that of the
+        target dataset.
+
+        .. versionadded:: 0.5.0
+    progress_bar : bool, default True
+        Use the library `tqdm` to show the progress bar for the upload,
+        chunk by chunk.
+
+        .. versionadded:: 0.5.0
+    credentials : google.auth.credentials.Credentials, optional
+        Credentials for accessing Google APIs. Use this parameter to override
+        default credentials, such as to use Compute Engine
+        :class:`google.auth.compute_engine.Credentials` or Service Account
+        :class:`google.oauth2.service_account.Credentials` directly.
+
+        .. versionadded:: 0.8.0
+    api_method : str, optional
+        API method used to upload DataFrame to BigQuery. One of "load_parquet",
+        "load_csv". Default "load_parquet" if pandas is version 1.1.0+,
+        otherwise "load_csv".
+
+        .. versionadded:: 0.16.0
+    verbose : bool, deprecated
+        Deprecated in Pandas-GBQ 0.4.0. Use the `logging module
+        to adjust verbosity instead
+        <https://pandas-gbq.readthedocs.io/en/latest/intro.html#logging>`__.
+    private_key : str, deprecated
+        Deprecated in pandas-gbq version 0.8.0. Use the ``credentials``
+        parameter and
+        :func:`google.oauth2.service_account.Credentials.from_service_account_info`
+        or
+        :func:`google.oauth2.service_account.Credentials.from_service_account_file`
+        instead.
+    auth_redirect_uri : str
+        Path to the authentication page for organization-specific authentication
+        workflows. Used when ``auth_local_webserver=False``.
+    client_id : str
+        The Client ID for the Google Cloud Project the user is attempting to
+        connect to.
+    client_secret : str
+        The Client Secret associated with the Client ID for the Google Cloud Project
+        the user is attempting to connect to.
+    user_agent : str
+        Custom user agent string used as a prefix to the pandas version.
+    rfc9110_delimiter : bool
+        Sets user agent delimiter to a hyphen or a slash.
+        Default is False, meaning a hyphen will be used.
+    bigquery_client : google.cloud.bigquery.Client, optional
+        A Google Cloud BigQuery Python Client instance. If provided, it will be used for reading
+        data, while the project, user_agent, and credentials parameters will be ignored.
+
+        .. versionadded:: 0.23.3
+    """
+
+    # If we get a bigframes.pandas.DataFrame object, it may be possible to use
+    # the code paths here, but it could potentially be quite expensive because
+    # of the queries involved in type detection. It would be safer just to
+    # fail early if there are bigframes-y methods available.
+    # https://github.com/googleapis/python-bigquery-pandas/issues/824
+    if hasattr(dataframe, "to_pandas") and hasattr(dataframe, "to_gbq"):
+        raise TypeError(f"Expected a pandas.DataFrame, but got {repr(type(dataframe))}")
+
+    _test_google_api_imports()
+
+    from google.api_core import exceptions as google_exceptions
+    from google.cloud import bigquery
+
+    if verbose is not None and FEATURES.pandas_has_deprecated_verbose:
+        warnings.warn(
+            "verbose is deprecated and will be removed in "
+            "a future version. Set logging level in order to vary "
+            "verbosity",
+            FutureWarning,
+            stacklevel=1,
+        )
+
+    if api_method == "default":
+        api_method = "load_parquet"
+
+    if chunksize is not None:
+        if api_method == "load_parquet":
+            warnings.warn(
+                "chunksize is ignored when using api_method='load_parquet'",
+                DeprecationWarning,
+                stacklevel=2,
+            )
+        else:
+            warnings.warn(
+                "chunksize will be ignored when using api_method='load_csv' in a future version of pandas-gbq",
+                PendingDeprecationWarning,
+                stacklevel=2,
+            )
+
+    if "." not in destination_table:
+        raise NotFoundException(
+            "Invalid Table Name. Should be of the form 'datasetId.tableId' or "
+            "'projectId.datasetId.tableId'"
+        )
+
+    if if_exists not in ("fail", "replace", "append"):
+        raise ValueError("'{0}' is not valid for if_exists".format(if_exists))
+
+    if_exists_list = ["fail", "replace", "append"]
+    dispositions = ["WRITE_EMPTY", "WRITE_TRUNCATE", "WRITE_APPEND"]
+    dispositions_dict = dict(zip(if_exists_list, dispositions))
+
+    write_disposition = dispositions_dict[if_exists]
+
+    connector = GbqConnector(
+        project_id,
+        reauth=reauth,
+        auth_local_webserver=auth_local_webserver,
+        location=location,
+        credentials=credentials,
+        private_key=private_key,
+        auth_redirect_uri=auth_redirect_uri,
+        client_id=client_id,
+        client_secret=client_secret,
+        user_agent=user_agent,
+        rfc9110_delimiter=rfc9110_delimiter,
+        bigquery_client=bigquery_client,
+    )
+    bqclient = connector.client
+
+    destination_table_ref = bigquery.table.TableReference.from_string(
+        destination_table, default_project=connector.project_id
+    )
+
+    project_id_table = destination_table_ref.project
+    dataset_id = destination_table_ref.dataset_id
+    table_id = destination_table_ref.table_id
+
+    default_schema = _generate_bq_schema(dataframe)
+    # If table_schema isn't provided, we'll create one for you
+    if not table_schema:
+        table_schema = default_schema
+    # It table_schema is provided, we'll update the default_schema to the provided table_schema
+    else:
+        table_schema = pandas_gbq.schema.update_schema(
+            default_schema, dict(fields=table_schema)
+        )
+
+    try:
+        # Try to get the table
+        table = bqclient.get_table(destination_table_ref)
+    except google_exceptions.NotFound:
+        # If the table doesn't already exist, create it
+        table_connector = _Table(
+            project_id_table,
+            dataset_id,
+            location=location,
+            credentials=connector.credentials,
+        )
+        table_connector.create(
+            table_id,
+            table_schema,
+            clustering_columns=clustering_columns,
+            time_partitioning_column=time_partitioning_column,
+            time_partitioning_type=time_partitioning_type,
+            time_partitioning_expiration_ms=time_partitioning_expiration_ms,
+            range_partitioning_column=range_partitioning_column,
+            range_partitioning_range=range_partitioning_range,
+        )
+    else:
+        if if_exists == "append":
+            # Convert original schema (the schema that already exists) to pandas-gbq API format
+            original_schema = pandas_gbq.schema.to_pandas_gbq(table.schema)
+
+            # Update the local `table_schema` so mode (NULLABLE/REQUIRED)
+            # matches. See: https://github.com/pydata/pandas-gbq/issues/315
+            table_schema = pandas_gbq.schema.update_schema(
+                table_schema, original_schema
+            )
+
+    if dataframe.empty:
+        # Create the table (if needed), but don't try to run a load job with an
+        # empty file. See: https://github.com/pydata/pandas-gbq/issues/237
+        return
+
+    connector.load_data(
+        dataframe,
+        destination_table_ref,
+        write_disposition=write_disposition,
+        chunksize=chunksize,
+        schema=table_schema,
+        progress_bar=progress_bar,
+        api_method=api_method,
+        billing_project=project_id,
+    )
+
+
+def generate_bq_schema(df, default_type="STRING"):
+    """DEPRECATED: Given a passed df, generate the associated Google BigQuery
+    schema.
+
+    Parameters
+    ----------
+    df : DataFrame
+    default_type : string
+        The default big query type in case the type of the column
+        does not exist in the schema.
+    """
+    # deprecation TimeSeries, #11121
+    warnings.warn(
+        "generate_bq_schema is deprecated and will be removed in " "a future version",
+        FutureWarning,
+        stacklevel=2,
+    )
+
+    return _generate_bq_schema(df, default_type=default_type)
+
+
+def _generate_bq_schema(df, default_type="STRING"):
+    """DEPRECATED: Given a dataframe, generate a Google BigQuery schema.
+
+    This is a private method, but was used in external code to work around
+    issues in the default schema generation. Now that individual columns can
+    be overridden: https://github.com/pydata/pandas-gbq/issues/218, this
+    method can be removed after there is time to migrate away from this
+    method."""
+    fields = pandas_gbq.schema.pandas_to_bigquery.dataframe_to_bigquery_fields(
+        df,
+        default_type=default_type,
+    )
+    fields_json = []
+
+    for field in fields:
+        fields_json.append(field.to_api_repr())
+
+    return {"fields": fields_json}
+
+
+class _Table(GbqConnector):
+    def __init__(
+        self,
+        project_id,
+        dataset_id,
+        reauth=False,
+        location=None,
+        credentials=None,
+        private_key=None,
+    ):
+        self.dataset_id = dataset_id
+        super(_Table, self).__init__(
+            project_id,
+            reauth,
+            location=location,
+            credentials=credentials,
+            private_key=private_key,
+        )
+
+    def _table_ref(self, table_id):
+        """Return a BigQuery client library table reference"""
+        from google.cloud.bigquery import DatasetReference, TableReference
+
+        return TableReference(
+            DatasetReference(self.project_id, self.dataset_id), table_id
+        )
+
+    def exists(self, table_id):
+        """Check if a table exists in Google BigQuery
+
+        Parameters
+        ----------
+        table : str
+            Name of table to be verified
+
+        Returns
+        -------
+        boolean
+            true if table exists, otherwise false
+        """
+        from google.api_core.exceptions import NotFound
+
+        table_ref = self._table_ref(table_id)
+        try:
+            self.client.get_table(table_ref)
+            return True
+        except NotFound:
+            return False
+        except self.http_error as ex:
+            self.process_http_error(ex)
+
+    def create(
+        self,
+        table_id,
+        schema,
+        clustering_columns=None,
+        time_partitioning_column=None,
+        time_partitioning_type="DAY",
+        time_partitioning_expiration_ms=None,
+        range_partitioning_column=None,
+        range_partitioning_range=None,
+    ):
+        """Create a table in Google BigQuery given a table and schema
+
+        Parameters
+        ----------
+        table : str
+            Name of table to be written
+        schema : str
+            Use the generate_bq_schema to generate your table schema from a
+            dataframe.
+        clustering_columns : list, optional
+            List of columns to cluster the table on.
+        time_partitioning_column : str, optional
+            Column to partition the table on.
+        time_partitioning_type : str, default 'DAY'
+            Type of time partitioning.
+        time_partitioning_expiration_ms : int, optional
+            Expiration time for the partitioning.
+        range_partitioning_column : str, optional
+            Column to partition the table on.
+        range_partitioning_range : dict, optional
+            Range for the partitioning.
+        """
+        from google.cloud.bigquery import (
+            DatasetReference,
+            PartitionRange,
+            RangePartitioning,
+            Table,
+            TableReference,
+            TimePartitioning,
+        )
+
+        if self.exists(table_id):
+            raise TableCreationError("Table {0} already exists".format(table_id))
+
+        if not _Dataset(self.project_id, credentials=self.credentials).exists(
+            self.dataset_id
+        ):
+            _Dataset(
+                self.project_id,
+                credentials=self.credentials,
+                location=self.location,
+            ).create(self.dataset_id)
+
+        table_ref = TableReference(
+            DatasetReference(self.project_id, self.dataset_id), table_id
+        )
+        table = Table(table_ref)
+        table.schema = pandas_gbq.schema.to_google_cloud_bigquery(schema)
+
+        if clustering_columns:
+            table.clustering_fields = list(clustering_columns)
+
+        if time_partitioning_column:
+            table.time_partitioning = TimePartitioning(
+                type_=time_partitioning_type,
+                field=time_partitioning_column,
+                expiration_ms=time_partitioning_expiration_ms,
+            )
+
+        if range_partitioning_column and range_partitioning_range:
+            table.range_partitioning = RangePartitioning(
+                field=range_partitioning_column,
+                range_=PartitionRange(
+                    start=range_partitioning_range["start"],
+                    end=range_partitioning_range["end"],
+                    interval=range_partitioning_range["interval"],
+                ),
+            )
+
+        try:
+            self.client.create_table(table)
+        except self.http_error as ex:
+            self.process_http_error(ex)
+
+    def delete(self, table_id):
+        """Delete a table in Google BigQuery
+
+        Parameters
+        ----------
+        table : str
+            Name of table to be deleted
+        """
+        from google.api_core.exceptions import NotFound
+
+        table_ref = self._table_ref(table_id)
+        try:
+            self.client.delete_table(table_ref)
+        except NotFound:
+            # Ignore 404 error which may occur if table already deleted
+            pass
+        except self.http_error as ex:
+            self.process_http_error(ex)
+
+
+class _Dataset(GbqConnector):
+    def __init__(
+        self,
+        project_id,
+        reauth=False,
+        location=None,
+        credentials=None,
+        private_key=None,
+    ):
+        super(_Dataset, self).__init__(
+            project_id,
+            reauth,
+            credentials=credentials,
+            location=location,
+            private_key=private_key,
+        )
+
+    def _dataset_ref(self, dataset_id):
+        """Return a BigQuery client library dataset reference"""
+        from google.cloud.bigquery import DatasetReference
+
+        return DatasetReference(self.project_id, dataset_id)
+
+    def exists(self, dataset_id):
+        """Check if a dataset exists in Google BigQuery
+
+        Parameters
+        ----------
+        dataset_id : str
+            Name of dataset to be verified
+
+        Returns
+        -------
+        boolean
+            true if dataset exists, otherwise false
+        """
+        from google.api_core.exceptions import NotFound
+
+        try:
+            self.client.get_dataset(self._dataset_ref(dataset_id))
+            return True
+        except NotFound:
+            return False
+        except self.http_error as ex:
+            self.process_http_error(ex)
+
+    def create(self, dataset_id):
+        """Create a dataset in Google BigQuery
+
+        Parameters
+        ----------
+        dataset : str
+            Name of dataset to be written
+        """
+        from google.cloud.bigquery import Dataset
+
+        if self.exists(dataset_id):
+            raise DatasetCreationError(
+                "Dataset {0} already " "exists".format(dataset_id)
+            )
+
+        dataset = Dataset(self._dataset_ref(dataset_id))
+
+        if self.location is not None:
+            dataset.location = self.location
+
+        try:
+            self.client.create_dataset(dataset)
+        except self.http_error as ex:
+            self.process_http_error(ex)
diff --git a/packages/pandas-gbq/pandas_gbq/gbq_connector.py b/packages/pandas-gbq/pandas_gbq/gbq_connector.py
new file mode 100644
index 000000000000..81f726f6c5bb
--- /dev/null
+++ b/packages/pandas-gbq/pandas_gbq/gbq_connector.py
@@ -0,0 +1,380 @@
+# Copyright (c) 2025 pandas-gbq Authors All rights reserved.
+# Use of this source code is governed by a BSD-style
+# license that can be found in the LICENSE file.
+
+from __future__ import annotations
+
+import logging
+import time
+import typing
+from typing import Any, Dict, Optional, Union
+import warnings
+
+# Only import at module-level at type checking time to avoid circular
+# dependencies in the pandas package, which has an optional dependency on
+# pandas-gbq.
+if typing.TYPE_CHECKING:  # pragma: NO COVER
+    import pandas
+
+import pandas_gbq.constants
+from pandas_gbq.contexts import context
+import pandas_gbq.core.read
+import pandas_gbq.environment as environment
+import pandas_gbq.exceptions
+from pandas_gbq.exceptions import QueryTimeout
+from pandas_gbq.features import FEATURES
+import pandas_gbq.query
+
+try:
+    import tqdm  # noqa
+except ImportError:
+    tqdm = None
+
+logger = logging.getLogger(__name__)
+
+
+class GbqConnector:
+    def __init__(
+        self,
+        project_id,
+        reauth=False,
+        private_key=None,
+        auth_local_webserver=True,
+        dialect="standard",
+        location=None,
+        credentials=None,
+        use_bqstorage_api=False,
+        auth_redirect_uri=None,
+        client_id=None,
+        client_secret=None,
+        user_agent=None,
+        rfc9110_delimiter=False,
+        bigquery_client=None,
+    ):
+        from pandas_gbq import auth
+
+        self.http_error = pandas_gbq.constants.HTTP_ERRORS
+        self.project_id = project_id
+        self.location = location
+        self.reauth = reauth
+        self.private_key = private_key
+        self.auth_local_webserver = auth_local_webserver
+        self.dialect = dialect
+        self.credentials = credentials
+        self.auth_redirect_uri = auth_redirect_uri
+        self.client_id = client_id
+        self.client_secret = client_secret
+        self.user_agent = user_agent
+        self.rfc9110_delimiter = rfc9110_delimiter
+        self.use_bqstorage_api = use_bqstorage_api
+
+        if bigquery_client is not None:
+            # If a bq client is already provided, use it to populate auth fields.
+            self.project_id = bigquery_client.project
+            self.credentials = bigquery_client._credentials
+            self.client = bigquery_client
+            return
+
+        default_project = None
+
+        # Service account credentials have a project associated with them.
+        # Prefer that project if none was supplied.
+        if self.project_id is None and hasattr(self.credentials, "project_id"):
+            self.project_id = credentials.project_id
+
+        # Load credentials from cache.
+        if not self.credentials:
+            self.credentials = context.credentials
+            default_project = context.project
+
+        # Credentials were explicitly asked for, so don't use the cache.
+        if private_key or reauth or not self.credentials:
+            self.credentials, default_project = auth.get_credentials(
+                private_key=private_key,
+                project_id=project_id,
+                reauth=reauth,
+                auth_local_webserver=auth_local_webserver,
+                auth_redirect_uri=auth_redirect_uri,
+                client_id=client_id,
+                client_secret=client_secret,
+            )
+
+        if self.project_id is None:
+            self.project_id = default_project
+
+        if self.project_id is None:
+            raise ValueError("Could not determine project ID and one was not supplied.")
+
+        # Cache the credentials if they haven't been set yet.
+        if context.credentials is None:
+            context.credentials = self.credentials
+        if context.project is None:
+            context.project = self.project_id
+
+        self.client = _get_client(
+            self.user_agent, self.rfc9110_delimiter, self.project_id, self.credentials
+        )
+
+    def _start_timer(self):
+        self.start = time.time()
+
+    def get_elapsed_seconds(self):
+        return round(time.time() - self.start, 2)
+
+    def log_elapsed_seconds(self, prefix="Elapsed", postfix="s.", overlong=6):
+        sec = self.get_elapsed_seconds()
+        if sec > overlong:
+            logger.info("{} {} {}".format(prefix, sec, postfix))
+
+    def get_client(self):
+        import google.api_core.client_info
+
+        bigquery = FEATURES.bigquery_try_import()
+
+        user_agent = create_user_agent(
+            user_agent=self.user_agent, rfc9110_delimiter=self.rfc9110_delimiter
+        )
+
+        client_info = google.api_core.client_info.ClientInfo(
+            user_agent=user_agent,
+        )
+        return bigquery.Client(
+            project=self.project_id,
+            credentials=self.credentials,
+            client_info=client_info,
+        )
+
+    @staticmethod
+    def process_http_error(ex):
+        # See `BigQuery Troubleshooting Errors
+        # <https://cloud.google.com/bigquery/troubleshooting-errors>`__
+        raise pandas_gbq.exceptions.translate_exception(ex) from ex
+
+    def download_table(
+        self,
+        table_id: str,
+        max_results: Optional[int] = None,
+        progress_bar_type: Optional[str] = None,
+        dtypes: Optional[Dict[str, Union[str, Any]]] = None,
+    ) -> Optional[pandas.DataFrame]:
+        from google.cloud import bigquery
+
+        self._start_timer()
+
+        try:
+            table_ref = bigquery.TableReference.from_string(
+                table_id, default_project=self.project_id
+            )
+            rows_iter = self.client.list_rows(table_ref, max_results=max_results)
+        except self.http_error as ex:
+            self.process_http_error(ex)
+
+        return self._download_results(
+            rows_iter,
+            max_results=max_results,
+            progress_bar_type=progress_bar_type,
+            user_dtypes=dtypes,
+        )
+
+    def run_query(self, query, max_results=None, progress_bar_type=None, **kwargs):
+        from google.cloud import bigquery
+
+        job_config_dict = {
+            "query": {
+                "useLegacySql": self.dialect
+                == "legacy"
+                # 'allowLargeResults', 'createDisposition',
+                # 'preserveNulls', destinationTable, useQueryCache
+            }
+        }
+        config = kwargs.get("configuration")
+        if config is not None:
+            job_config_dict.update(config)
+
+        timeout_ms = job_config_dict.get("jobTimeoutMs") or job_config_dict[
+            "query"
+        ].get("timeoutMs")
+
+        if timeout_ms:
+            timeout_ms = int(timeout_ms)
+            # Having too small a timeout_ms results in individual
+            # API calls timing out before they can finish.
+            # ~300 milliseconds is rule of thumb for bare minimum
+            # latency from the BigQuery API, however, 400 milliseconds
+            # produced too many issues with flakybot failures.
+            minimum_latency = 500
+            if timeout_ms < minimum_latency:
+                raise QueryTimeout(
+                    f"Query timeout must be at least 500 milliseconds: timeout_ms equals {timeout_ms}."
+                )
+        else:
+            timeout_ms = None
+
+        self._start_timer()
+        job_config = bigquery.QueryJobConfig.from_api_repr(job_config_dict)
+
+        if FEATURES.bigquery_has_query_and_wait:
+            rows_iter = pandas_gbq.query.query_and_wait_via_client_library(
+                self,
+                self.client,
+                query,
+                location=self.location,
+                project_id=self.project_id,
+                job_config=job_config,
+                max_results=max_results,
+                timeout_ms=timeout_ms,
+            )
+        else:
+            rows_iter = pandas_gbq.query.query_and_wait(
+                self,
+                self.client,
+                query,
+                location=self.location,
+                project_id=self.project_id,
+                job_config=job_config,
+                max_results=max_results,
+                timeout_ms=timeout_ms,
+            )
+
+        dtypes = kwargs.get("dtypes")
+        return self._download_results(
+            rows_iter,
+            max_results=max_results,
+            progress_bar_type=progress_bar_type,
+            user_dtypes=dtypes,
+        )
+
+    def _download_results(
+        self,
+        rows_iter,
+        max_results=None,
+        progress_bar_type=None,
+        user_dtypes=None,
+    ):
+        return pandas_gbq.core.read.download_results(
+            rows_iter,
+            bqclient=self.get_client(),
+            progress_bar_type=progress_bar_type,
+            warn_on_large_results=True,
+            max_results=max_results,
+            user_dtypes=user_dtypes,
+            use_bqstorage_api=self.use_bqstorage_api,
+        )
+
+    def load_data(
+        self,
+        dataframe,
+        destination_table_ref,
+        write_disposition,
+        chunksize=None,
+        schema=None,
+        progress_bar=True,
+        api_method: str = "load_parquet",
+        billing_project: Optional[str] = None,
+    ):
+        from pandas_gbq import load
+
+        total_rows = len(dataframe)
+
+        try:
+            chunks = load.load_chunks(
+                self.client,
+                dataframe,
+                destination_table_ref,
+                chunksize=chunksize,
+                schema=schema,
+                location=self.location,
+                api_method=api_method,
+                write_disposition=write_disposition,
+                billing_project=billing_project,
+            )
+            if progress_bar and tqdm:
+                chunks = tqdm.tqdm(chunks)
+            for remaining_rows in chunks:
+                logger.info(
+                    "\r{} out of {} rows loaded.".format(
+                        total_rows - remaining_rows, total_rows
+                    )
+                )
+        except self.http_error as ex:
+            self.process_http_error(ex)
+
+
+def _get_client(user_agent, rfc9110_delimiter, project_id, credentials):
+    import google.api_core.client_info
+
+    bigquery = FEATURES.bigquery_try_import()
+
+    user_agent = create_user_agent(
+        user_agent=user_agent, rfc9110_delimiter=rfc9110_delimiter
+    )
+
+    client_info = google.api_core.client_info.ClientInfo(
+        user_agent=user_agent,
+    )
+    return bigquery.Client(
+        project=project_id,
+        credentials=credentials,
+        client_info=client_info,
+    )
+
+
+def create_user_agent(
+    user_agent: Optional[str] = None, rfc9110_delimiter: bool = False
+) -> str:
+    """Creates a user agent string.
+
+    The legacy format of our the user agent string was: `product-x.y.z` (where x,
+    y, and z are the major, minor, and micro version numbers).
+
+    Users are able to prepend this string with their own user agent identifier
+    to render something similar to `<my_user_agent> pandas-x.y.z`.
+
+    The legacy format used a hyphen to separate the product from the product
+    version which differs slightly from the format recommended by RFC9110, which is:
+    `product/x.y.z`. To produce a user agent more in line with the RFC, set
+    rfc9110_delimiter to True. This setting does not depend on whether a
+    user_agent is also supplied.
+
+    Reference:
+        https://www.rfc-editor.org/info/rfc9110
+
+    Args:
+        user_agent (Optional[str]): User agent string.
+
+        rfc9110_delimiter (Optional[bool]): Sets delimiter to a hyphen or a slash.
+        Default is False, meaning a hyphen will be used.
+
+    Returns (str):
+        Customized user agent string.
+
+    Deprecation Warning:
+        In a future major release, the default delimiter will be changed to
+        a `/` in accordance with RFC9110.
+    """
+    import pandas as pd
+
+    if rfc9110_delimiter:
+        delimiter = "/"
+    else:
+        warnings.warn(
+            "In a future major release, the default delimiter will be "
+            "changed to a `/` in accordance with RFC9110.",
+            PendingDeprecationWarning,
+            stacklevel=2,
+        )
+        delimiter = "-"
+
+    identities = [] if user_agent is None else [user_agent]
+    identities.append(f"pandas{delimiter}{pd.__version__}")
+
+    if environment.is_vscode():
+        identities.append("vscode")
+        if environment.is_vscode_google_cloud_code_extension_installed():
+            identities.append(environment.GOOGLE_CLOUD_CODE_EXTENSION_NAME)
+    elif environment.is_jupyter():
+        identities.append("jupyter")
+        if environment.is_jupyter_bigquery_plugin_installed():
+            identities.append(environment.BIGQUERY_JUPYTER_PLUGIN_NAME)
+
+    return " ".join(identities)
diff --git a/packages/pandas-gbq/pandas_gbq/load/__init__.py b/packages/pandas-gbq/pandas_gbq/load/__init__.py
new file mode 100644
index 000000000000..250d65176865
--- /dev/null
+++ b/packages/pandas-gbq/pandas_gbq/load/__init__.py
@@ -0,0 +1,23 @@
+# Copyright (c) 2025 pandas-gbq Authors All rights reserved.
+# Use of this source code is governed by a BSD-style
+# license that can be found in the LICENSE file.
+
+from pandas_gbq.load.core import (
+    cast_dataframe_for_parquet,
+    encode_chunk,
+    load_chunks,
+    load_csv_from_dataframe,
+    load_csv_from_file,
+    load_parquet,
+    split_dataframe,
+)
+
+__all__ = [
+    "cast_dataframe_for_parquet",
+    "encode_chunk",
+    "load_chunks",
+    "load_csv_from_dataframe",
+    "load_csv_from_file",
+    "load_parquet",
+    "split_dataframe",
+]
diff --git a/packages/pandas-gbq/pandas_gbq/load/core.py b/packages/pandas-gbq/pandas_gbq/load/core.py
new file mode 100644
index 000000000000..d98f83068b7f
--- /dev/null
+++ b/packages/pandas-gbq/pandas_gbq/load/core.py
@@ -0,0 +1,281 @@
+# Copyright (c) 2017 pandas-gbq Authors All rights reserved.
+# Use of this source code is governed by a BSD-style
+# license that can be found in the LICENSE file.
+
+"""Helper methods for loading data into BigQuery"""
+
+import decimal
+import io
+from typing import Any, Callable, Dict, List, Optional
+
+import db_dtypes
+from google.cloud import bigquery
+import pandas
+import pyarrow.lib
+
+from pandas_gbq import exceptions
+import pandas_gbq.schema
+import pandas_gbq.schema.bigquery
+import pandas_gbq.schema.pandas_to_bigquery
+
+
+def encode_chunk(dataframe):
+    """Return a file-like object of CSV-encoded rows.
+
+    Args:
+      dataframe (pandas.DataFrame): A chunk of a dataframe to encode
+    """
+    csv_buffer = io.StringIO()
+    dataframe.to_csv(
+        csv_buffer,
+        index=False,
+        header=False,
+        encoding="utf-8",
+        float_format="%.17g",
+        date_format="%Y-%m-%d %H:%M:%S.%f",
+    )
+
+    # Convert to a BytesIO buffer so that unicode text is properly handled.
+    # See: https://github.com/pydata/pandas-gbq/issues/106
+    body = csv_buffer.getvalue()
+    body = body.encode("utf-8")
+    return io.BytesIO(body)
+
+
+def split_dataframe(dataframe, chunksize=None):
+    dataframe = dataframe.reset_index(drop=True)
+    if chunksize is None:
+        yield 0, dataframe
+        return
+
+    remaining_rows = len(dataframe)
+    total_rows = remaining_rows
+    start_index = 0
+    while start_index < total_rows:
+        end_index = start_index + chunksize
+        chunk = dataframe[start_index:end_index]
+        start_index += chunksize
+        remaining_rows = max(0, remaining_rows - chunksize)
+        yield remaining_rows, chunk
+
+
+def cast_dataframe_for_parquet(
+    dataframe: pandas.DataFrame,
+    schema: Optional[Dict[str, Any]],
+) -> pandas.DataFrame:
+    """Cast columns to needed dtype when writing parquet files.
+
+    See: https://github.com/googleapis/python-bigquery-pandas/issues/421
+    """
+
+    columns = schema.get("fields", [])
+
+    # Protect against an explicit None in the dictionary.
+    columns = columns if columns is not None else []
+
+    for column in columns:
+        # Schema can be a superset of the columns in the dataframe, so ignore
+        # columns that aren't present.
+        column_name = column.get("name")
+        if column_name not in dataframe.columns:
+            continue
+
+        # Skip array columns for now. Potentially casting the elements of the
+        # array would be possible, but not worth the effort until there is
+        # demand for it.
+        if column.get("mode", "NULLABLE").upper() == "REPEATED":
+            continue
+
+        column_type = column.get("type", "").upper()
+        if (
+            column_type == "DATE"
+            # Use extension dtype first so that it uses the correct equality operator.
+            and db_dtypes.DateDtype() != dataframe[column_name].dtype
+        ):
+            cast_column = dataframe[column_name].astype(
+                dtype=db_dtypes.DateDtype(),
+                # Return the original column if there was an error converting
+                # to the dtype, such as is there is a date outside the
+                # supported range.
+                # https://github.com/googleapis/python-bigquery-pandas/issues/441
+                errors="ignore",
+            )
+        elif column_type in {"NUMERIC", "DECIMAL", "BIGNUMERIC", "BIGDECIMAL"}:
+            # decimal.Decimal does not support `None` or `pandas.NA` input, add
+            # support here.
+            # https://github.com/googleapis/python-bigquery-pandas/issues/719
+            def convert(x):
+                if pandas.isna(x):  # true for `None` and `pandas.NA`
+                    return decimal.Decimal("NaN")
+                else:
+                    return decimal.Decimal(x)
+
+            cast_column = dataframe[column_name].map(convert)
+        elif column_type == "STRING":
+            # Allow non-string columns to be uploaded to STRING in BigQuery.
+            # https://github.com/googleapis/python-bigquery-pandas/issues/875
+            # TODO: Use pyarrow as the storage when the minimum pandas version allows for it.
+            cast_column = dataframe[column_name].astype(pandas.StringDtype())
+        else:
+            cast_column = None
+
+        if cast_column is not None:
+            dataframe = dataframe.assign(**{column_name: cast_column})
+    return dataframe
+
+
+def load_parquet(
+    client: bigquery.Client,
+    dataframe: pandas.DataFrame,
+    destination_table_ref: bigquery.TableReference,
+    write_disposition: str,
+    location: Optional[str],
+    schema: Optional[Dict[str, Any]],
+    billing_project: Optional[str] = None,
+):
+    job_config = bigquery.LoadJobConfig()
+    job_config.write_disposition = write_disposition
+    job_config.source_format = "PARQUET"
+
+    if schema is not None:
+        schema = pandas_gbq.schema.remove_policy_tags(schema)
+        job_config.schema = pandas_gbq.schema.to_google_cloud_bigquery(schema)
+        dataframe = cast_dataframe_for_parquet(dataframe, schema)
+
+    try:
+        client.load_table_from_dataframe(
+            dataframe,
+            destination_table_ref,
+            job_config=job_config,
+            location=location,
+            project=billing_project,
+        ).result()
+    except pyarrow.lib.ArrowInvalid as exc:
+        raise exceptions.ConversionError(
+            "Could not convert DataFrame to Parquet."
+        ) from exc
+
+
+def load_csv(
+    dataframe: pandas.DataFrame,
+    write_disposition: str,
+    chunksize: Optional[int],
+    bq_schema: Optional[List[bigquery.SchemaField]],
+    load_chunk: Callable,
+):
+    job_config = bigquery.LoadJobConfig()
+    job_config.write_disposition = write_disposition
+    job_config.source_format = "CSV"
+    job_config.allow_quoted_newlines = True
+
+    if bq_schema is not None:
+        job_config.schema = bq_schema
+
+    # TODO: Remove chunking feature for load jobs. Deprecated in 0.16.0.
+    chunks = split_dataframe(dataframe, chunksize=chunksize)
+    for remaining_rows, chunk in chunks:
+        yield remaining_rows
+        load_chunk(chunk, job_config)
+
+
+def load_csv_from_dataframe(
+    client: bigquery.Client,
+    dataframe: pandas.DataFrame,
+    destination_table_ref: bigquery.TableReference,
+    write_disposition: str,
+    location: Optional[str],
+    chunksize: Optional[int],
+    schema: Optional[Dict[str, Any]],
+    billing_project: Optional[str] = None,
+):
+    bq_schema = None
+
+    if schema is not None:
+        schema = pandas_gbq.schema.remove_policy_tags(schema)
+        bq_schema = pandas_gbq.schema.to_google_cloud_bigquery(schema)
+
+    def load_chunk(chunk, job_config):
+        client.load_table_from_dataframe(
+            chunk,
+            destination_table_ref,
+            job_config=job_config,
+            location=location,
+            project=billing_project,
+        ).result()
+
+    return load_csv(dataframe, write_disposition, chunksize, bq_schema, load_chunk)
+
+
+def load_csv_from_file(
+    client: bigquery.Client,
+    dataframe: pandas.DataFrame,
+    destination_table_ref: bigquery.TableReference,
+    write_disposition: str,
+    location: Optional[str],
+    chunksize: Optional[int],
+    schema: Optional[Dict[str, Any]],
+    billing_project: Optional[str] = None,
+):
+    """Manually encode a DataFrame to CSV and use the buffer in a load job.
+
+    This method is needed for writing with google-cloud-bigquery versions that
+    don't implment load_table_from_dataframe with the CSV serialization format.
+    """
+    bq_schema = pandas_gbq.schema.pandas_to_bigquery.dataframe_to_bigquery_fields(
+        dataframe, schema
+    )
+
+    def load_chunk(chunk, job_config):
+        try:
+            chunk_buffer = encode_chunk(chunk)
+            client.load_table_from_file(
+                chunk_buffer,
+                destination_table_ref,
+                job_config=job_config,
+                location=location,
+                project=billing_project,
+            ).result()
+        finally:
+            chunk_buffer.close()
+
+    return load_csv(dataframe, write_disposition, chunksize, bq_schema, load_chunk)
+
+
+def load_chunks(
+    client,
+    dataframe,
+    destination_table_ref,
+    chunksize=None,
+    schema=None,
+    location=None,
+    api_method="load_parquet",
+    write_disposition="WRITE_EMPTY",
+    billing_project: Optional[str] = None,
+):
+    if api_method == "load_parquet":
+        load_parquet(
+            client,
+            dataframe,
+            destination_table_ref,
+            write_disposition,
+            location,
+            schema,
+            billing_project=billing_project,
+        )
+        # TODO: yield progress depending on result() with timeout
+        return [0]
+    elif api_method == "load_csv":
+        return load_csv_from_dataframe(
+            client,
+            dataframe,
+            destination_table_ref,
+            write_disposition,
+            location,
+            chunksize,
+            schema,
+            billing_project=billing_project,
+        )
+    else:
+        raise ValueError(
+            f"Got unexpected api_method: {api_method!r}, expected one of 'load_parquet', 'load_csv'."
+        )
diff --git a/packages/pandas-gbq/pandas_gbq/query.py b/packages/pandas-gbq/pandas_gbq/query.py
new file mode 100644
index 000000000000..83575a9cc3c8
--- /dev/null
+++ b/packages/pandas-gbq/pandas_gbq/query.py
@@ -0,0 +1,211 @@
+# Copyright (c) 2017 pandas-gbq Authors All rights reserved.
+# Use of this source code is governed by a BSD-style
+# license that can be found in the LICENSE file.
+
+from __future__ import annotations
+
+import concurrent.futures
+import functools
+import logging
+from typing import Optional
+
+import google.auth.exceptions
+from google.cloud import bigquery
+
+import pandas_gbq.exceptions
+
+logger = logging.getLogger(__name__)
+
+
+# On-demand BQ Queries costs $6.25 per TB. First 1 TB per month is free
+# see here for more: https://cloud.google.com/bigquery/pricing
+QUERY_PRICE_FOR_TB = 6.25 / 2**40  # USD/TB
+
+
+# http://stackoverflow.com/questions/1094841/reusable-library-to-get-human-readable-version-of-file-size
+def sizeof_fmt(num, suffix="B"):
+    fmt = "%3.1f %s%s"
+    for unit in ["", "K", "M", "G", "T", "P", "E", "Z"]:
+        if abs(num) < 1024.0:
+            return fmt % (num, unit, suffix)
+        num /= 1024.0
+    return fmt % (num, "Y", suffix)
+
+
+def _wait_for_query_job(
+    connector,
+    client: bigquery.Client,
+    query_reply: bigquery.QueryJob,
+    timeout_ms: Optional[float],
+):
+    """Wait for query to complete, pausing occasionally to update progress.
+
+    Args:
+        connector (GbqConnector):
+            General pandas-gbq "connector" with helpers for stateful progress
+            logs and error raising.
+
+        client (bigquery.Client):
+            A connection to BigQuery, used to make API requests.
+
+        query_reply (QueryJob):
+            A query job which has started.
+
+        timeout_ms (Optional[int]):
+            How long to wait before cancelling the query.
+    """
+    # Wait at most 10 seconds so we can show progress.
+    # TODO(https://github.com/googleapis/python-bigquery-pandas/issues/327):
+    # Include a tqdm progress bar here instead of a stream of log messages.
+    timeout_sec = 10.0
+    if timeout_ms:
+        timeout_sec = min(timeout_sec, timeout_ms / 1000.0)
+
+    while query_reply.state != "DONE":
+        connector.log_elapsed_seconds("  Elapsed", "s. Waiting...")
+
+        if timeout_ms and timeout_ms < connector.get_elapsed_seconds() * 1000:
+            client.cancel_job(query_reply.job_id, location=query_reply.location)
+            raise pandas_gbq.exceptions.QueryTimeout(
+                "Query timeout: {} ms".format(timeout_ms)
+            )
+
+        try:
+            query_reply.result(timeout=timeout_sec)
+        except concurrent.futures.TimeoutError:
+            # Use our own timeout logic
+            pass
+        except connector.http_error as ex:
+            connector.process_http_error(ex)
+
+
+def try_query(connector, query_fn):
+    try:
+        logger.debug("Requesting query... ")
+        return query_fn()
+    except concurrent.futures.TimeoutError as ex:
+        raise pandas_gbq.exceptions.QueryTimeout("Reason: {0}".format(ex))
+    except (google.auth.exceptions.RefreshError, ValueError) as ex:
+        if connector.private_key:
+            raise pandas_gbq.exceptions.AccessDenied(
+                f"The service account credentials are not valid: {ex}"
+            )
+        else:
+            raise pandas_gbq.exceptions.AccessDenied(
+                "The credentials have been revoked or expired, "
+                f"please re-run the application to re-authorize: {ex}"
+            )
+    except connector.http_error as ex:
+        connector.process_http_error(ex)
+
+
+def query_and_wait(
+    connector,
+    client: bigquery.Client,
+    query: str,
+    *,
+    job_config: bigquery.QueryJobConfig,
+    location: Optional[str],
+    project_id: Optional[str],
+    max_results: Optional[int],
+    timeout_ms: Optional[int],
+):
+    """Start a query and wait for it to complete.
+
+    Args:
+        connector (GbqConnector):
+            General pandas-gbq "connector" with helpers for stateful progress
+            logs and error raising.
+
+        client (bigquery.Client):
+            A connection to BigQuery, used to make API requests.
+
+        query (str):
+            The text of the query to run.
+
+        job_config (bigquery.QueryJobConfig):
+            Options for running the query.
+
+        location (Optional[str]):
+            BigQuery location to run the query. Uses the default if not set.
+
+        project (Optional[str]):
+            GCP project ID where to run the query. Uses the default if not set.
+
+        max_results (Optional[int]):
+            Maximum number of rows in the result set.
+
+        timeout_ms (Optional[int]):
+            How long to wait before cancelling the query.
+
+    Returns:
+        bigquery.RowIterator:
+            Result iterator from which we can download the results in the
+            desired format (pandas.DataFrame).
+    """
+    query_reply = try_query(
+        connector,
+        functools.partial(
+            client.query,
+            query,
+            job_config=job_config,
+            location=location,
+            project=project_id,
+        ),
+    )
+    logger.debug("Query running...")
+
+    job_id = query_reply.job_id
+    logger.debug("Job ID: %s" % job_id)
+
+    _wait_for_query_job(connector, connector.client, query_reply, timeout_ms)
+
+    if query_reply.cache_hit:
+        logger.debug("Query done.\nCache hit.\n")
+    else:
+        bytes_processed = query_reply.total_bytes_processed or 0
+        bytes_billed = query_reply.total_bytes_billed or 0
+        logger.debug(
+            "Query done.\nProcessed: {} Billed: {}".format(
+                sizeof_fmt(bytes_processed),
+                sizeof_fmt(bytes_billed),
+            )
+        )
+        logger.debug(
+            "Standard price: ${:,.2f} USD\n".format(bytes_billed * QUERY_PRICE_FOR_TB)
+        )
+
+    # As of google-cloud-bigquery 2.3.0, QueryJob.result() uses
+    # getQueryResults() instead of tabledata.list, which returns the correct
+    # response with DML/DDL queries.
+    try:
+        return query_reply.result(max_results=max_results)
+    except connector.http_error as ex:
+        connector.process_http_error(ex)
+
+
+def query_and_wait_via_client_library(
+    connector,
+    client: bigquery.Client,
+    query: str,
+    *,
+    job_config: bigquery.QueryJobConfig,
+    location: Optional[str],
+    project_id: Optional[str],
+    max_results: Optional[int],
+    timeout_ms: Optional[int],
+):
+    rows_iter = try_query(
+        connector,
+        functools.partial(
+            client.query_and_wait,
+            query,
+            job_config=job_config,
+            location=location,
+            project=project_id,
+            max_results=max_results,
+            wait_timeout=timeout_ms / 1000.0 if timeout_ms else None,
+        ),
+    )
+    logger.debug("Query done.\n")
+    return rows_iter
diff --git a/packages/pandas-gbq/pandas_gbq/schema/__init__.py b/packages/pandas-gbq/pandas_gbq/schema/__init__.py
new file mode 100644
index 000000000000..350a1d2e394b
--- /dev/null
+++ b/packages/pandas-gbq/pandas_gbq/schema/__init__.py
@@ -0,0 +1,148 @@
+# Copyright (c) 2017 pandas-gbq Authors All rights reserved.
+# Use of this source code is governed by a BSD-style
+# license that can be found in the LICENSE file.
+
+"""Helper methods for BigQuery schemas"""
+
+import copy
+
+# API may return data types as legacy SQL, so maintain a mapping of aliases
+# from standard SQL to legacy data types.
+_TYPE_ALIASES = {
+    "BOOL": "BOOLEAN",
+    "FLOAT64": "FLOAT",
+    "INT64": "INTEGER",
+    "STRUCT": "RECORD",
+}
+
+
+def to_pandas_gbq(client_schema):
+    """Given a sequence of :class:`google.cloud.bigquery.schema.SchemaField`,
+    return a schema in pandas-gbq API format.
+    """
+    remote_fields = [
+        # Filter out default values. google-cloud-bigquery versions before
+        # 2.31.0 (https://github.com/googleapis/python-bigquery/pull/557)
+        # include a description key, even if not explicitly set. This has the
+        # potential to unset the description unintentionally in cases where
+        # pandas-gbq is updating the schema.
+        {
+            key: value
+            for key, value in field_remote.to_api_repr().items()
+            if value is not None
+        }
+        for field_remote in client_schema
+    ]
+    for field in remote_fields:
+        field["type"] = field["type"].upper()
+        field["mode"] = field["mode"].upper()
+
+    return {"fields": remote_fields}
+
+
+def to_google_cloud_bigquery(pandas_gbq_schema):
+    """Given a schema in pandas-gbq API format,
+    return a sequence of :class:`google.cloud.bigquery.schema.SchemaField`.
+    """
+    from google.cloud import bigquery
+
+    # Need to convert from JSON representation to format used by client library.
+    schema = add_default_nullable_mode(pandas_gbq_schema)
+    return [bigquery.SchemaField.from_api_repr(field) for field in schema["fields"]]
+
+
+def _clean_schema_fields(fields):
+    """Return a sanitized version of the schema for comparisons.
+
+    The ``mode`` and ``description`` properties areis ignored because they
+    are not generated by func:`pandas_gbq.schema.generate_bq_schema`.
+    """
+    fields_sorted = sorted(fields, key=lambda field: field["name"])
+    clean_schema = []
+    for field in fields_sorted:
+        field_type = field["type"].upper()
+        field_type = _TYPE_ALIASES.get(field_type, field_type)
+        clean_schema.append({"name": field["name"], "type": field_type})
+    return clean_schema
+
+
+def schema_is_subset(schema_remote, schema_local):
+    """Indicate whether the schema to be uploaded is a subset
+
+    Compare the BigQuery table identified in the parameters with
+    the schema passed in and indicate whether a subset of the fields in
+    the former are present in the latter. Order is not considered.
+
+    Parameters
+    ----------
+    schema_remote : dict
+        Schema for comparison. Each item of ``fields`` should have a 'name'
+        and a 'type'
+    schema_local : dict
+        Schema for comparison. Each item of ``fields`` should have a 'name'
+        and a 'type'
+
+    Returns
+    -------
+    bool
+        Whether the passed schema is a subset
+    """
+    fields_remote = _clean_schema_fields(schema_remote.get("fields", []))
+    fields_local = _clean_schema_fields(schema_local.get("fields", []))
+    return all(field in fields_remote for field in fields_local)
+
+
+def update_schema(schema_old, schema_new):
+    """
+    Given an old BigQuery schema, update it with a new one.
+
+    Where a field name is the same, the new will replace the old. Any
+    new fields not present in the old schema will be added.
+
+    Arguments:
+        schema_old: the old schema to update
+        schema_new: the new schema which will overwrite/extend the old
+    """
+    old_fields = schema_old["fields"]
+    new_fields = schema_new["fields"]
+    output_fields = list(old_fields)
+
+    field_indices = {field["name"]: i for i, field in enumerate(output_fields)}
+
+    for field in new_fields:
+        name = field["name"]
+        if name in field_indices:
+            # replace old field with new field of same name
+            output_fields[field_indices[name]] = field
+
+    return {"fields": output_fields}
+
+
+def add_default_nullable_mode(schema):
+    """Manually create the schema objects, adding NULLABLE mode.
+
+    Workaround for error in SchemaField.from_api_repr, which required
+    "mode" to be set:
+    https://github.com/GoogleCloudPlatform/google-cloud-python/issues/4456
+    """
+    # Returns a copy rather than modifying the mutable arg,
+    # per Issue #277
+    result = copy.deepcopy(schema)
+    for field in result["fields"]:
+        field.setdefault("mode", "NULLABLE")
+    return result
+
+
+def remove_policy_tags(schema):
+    """Manually create the schema objects, removing policyTags.
+
+    Workaround for 403 error with policy tags, which are not required in a load
+    job: https://github.com/googleapis/python-bigquery/pull/557
+    """
+    # Returns a copy rather than modifying the mutable arg,
+    # per Issue #277
+    result = copy.deepcopy(schema)
+    for field in result["fields"]:
+        if "policyTags" in field:
+            del field["policyTags"]
+    return result
diff --git a/packages/pandas-gbq/pandas_gbq/schema/bigquery.py b/packages/pandas-gbq/pandas_gbq/schema/bigquery.py
new file mode 100644
index 000000000000..0de21978bc4e
--- /dev/null
+++ b/packages/pandas-gbq/pandas_gbq/schema/bigquery.py
@@ -0,0 +1,44 @@
+# Copyright (c) 2019 pandas-gbq Authors All rights reserved.
+# Use of this source code is governed by a BSD-style
+# license that can be found in the LICENSE file.
+
+import collections
+
+import google.cloud.bigquery
+
+
+def to_schema_fields(schema):
+    """Coerce `schema` to a list of schema field instances.
+
+    Args:
+        schema(Sequence[Union[ \
+            :class:`~google.cloud.bigquery.schema.SchemaField`, \
+            Mapping[str, Any] \
+        ]]):
+            Table schema to convert. If some items are passed as mappings,
+            their content must be compatible with
+            :meth:`~google.cloud.bigquery.schema.SchemaField.from_api_repr`.
+
+    Returns:
+        Sequence[:class:`~google.cloud.bigquery.schema.SchemaField`]
+
+    Raises:
+        Exception: If ``schema`` is not a sequence, or if any item in the
+        sequence is not a :class:`~google.cloud.bigquery.schema.SchemaField`
+        instance or a compatible mapping representation of the field.
+    """
+    for field in schema:
+        if not isinstance(
+            field, (google.cloud.bigquery.SchemaField, collections.abc.Mapping)
+        ):
+            raise ValueError(
+                "Schema items must either be fields or compatible "
+                "mapping representations."
+            )
+
+    return [
+        field
+        if isinstance(field, google.cloud.bigquery.SchemaField)
+        else google.cloud.bigquery.SchemaField.from_api_repr(field)
+        for field in schema
+    ]
diff --git a/packages/pandas-gbq/pandas_gbq/schema/pandas_to_bigquery.py b/packages/pandas-gbq/pandas_gbq/schema/pandas_to_bigquery.py
new file mode 100644
index 000000000000..f2a56f527e3d
--- /dev/null
+++ b/packages/pandas-gbq/pandas_gbq/schema/pandas_to_bigquery.py
@@ -0,0 +1,293 @@
+# Copyright (c) 2019 pandas-gbq Authors All rights reserved.
+# Use of this source code is governed by a BSD-style
+# license that can be found in the LICENSE file.
+
+import collections.abc
+import datetime
+from typing import Any, Optional, Tuple
+import warnings
+
+import db_dtypes
+from google.cloud.bigquery import schema
+import pandas
+import pyarrow
+
+import pandas_gbq.core.pandas
+import pandas_gbq.schema.bigquery
+import pandas_gbq.schema.pyarrow_to_bigquery
+
+try:
+    # _BaseGeometry is used to detect shapely objects in `bq_to_arrow_array`
+    from shapely.geometry.base import BaseGeometry as _BaseGeometry  # type: ignore
+except ImportError:
+    # No shapely, use NoneType for _BaseGeometry as a placeholder.
+    _BaseGeometry = type(None)
+
+
+# If you update this mapping, also update the table at
+# `docs/source/writing.rst`.
+_PANDAS_DTYPE_TO_BQ = {
+    "bool": "BOOLEAN",
+    "boolean": "BOOLEAN",
+    "datetime64[ns, UTC]": "TIMESTAMP",
+    "datetime64[us, UTC]": "TIMESTAMP",
+    "datetime64[ns]": "DATETIME",
+    "datetime64[us]": "DATETIME",
+    "float32": "FLOAT",
+    "float64": "FLOAT",
+    "int8": "INTEGER",
+    "int16": "INTEGER",
+    "int32": "INTEGER",
+    "int64": "INTEGER",
+    "Int8": "INTEGER",
+    "Int16": "INTEGER",
+    "Int32": "INTEGER",
+    "Int64": "INTEGER",
+    "uint8": "INTEGER",
+    "uint16": "INTEGER",
+    "uint32": "INTEGER",
+    "geometry": "GEOGRAPHY",
+    db_dtypes.DateDtype.name: "DATE",
+    db_dtypes.TimeDtype.name: "TIME",
+    # TODO(tswast): Add support for JSON.
+}
+
+
+def dataframe_to_bigquery_fields(
+    dataframe,
+    override_bigquery_fields=None,
+    default_type="STRING",
+    index=False,
+) -> Tuple[schema.SchemaField]:
+    """Convert a pandas DataFrame schema to a BigQuery schema.
+
+    Args:
+        dataframe (pandas.DataFrame):
+            DataFrame for which the client determines the BigQuery schema.
+        override_bigquery_fields (Sequence[Union[ \
+            :class:`~google.cloud.bigquery.schema.SchemaField`, \
+            Mapping[str, Any] \
+        ]]):
+            A BigQuery schema. Use this argument to override the autodetected
+            type for some or all of the DataFrame columns.
+
+    Returns:
+        Optional[Sequence[google.cloud.bigquery.schema.SchemaField]]:
+            The automatically determined schema. Returns None if the type of
+            any column cannot be determined.
+    """
+    if override_bigquery_fields:
+        override_bigquery_fields = pandas_gbq.schema.bigquery.to_schema_fields(
+            override_bigquery_fields
+        )
+        override_fields_by_name = {
+            field.name: field for field in override_bigquery_fields
+        }
+        override_fields_unused = set(override_fields_by_name.keys())
+    else:
+        override_fields_by_name = {}
+        override_fields_unused = set()
+
+    bq_schema_out = []
+    unknown_type_fields = []
+
+    # TODO(tswast): Support index=True in to_gbq.
+    for column, dtype in pandas_gbq.core.pandas.list_columns_and_indexes(
+        dataframe, index=index
+    ):
+        # Use provided type from schema, if present.
+        bq_field = override_fields_by_name.get(column)
+        if bq_field:
+            bq_schema_out.append(bq_field)
+            override_fields_unused.discard(bq_field.name)
+            continue
+
+        # Try to automatically determine the type based on the pandas dtype.
+        bq_field = dtype_to_bigquery_field(column, dtype)
+        if bq_field:
+            bq_schema_out.append(bq_field)
+            continue
+
+        # Try to automatically determine the type based on a few rows of the data.
+        values = dataframe.reset_index()[column]
+        bq_field = values_to_bigquery_field(column, values, default_type=default_type)
+
+        if bq_field:
+            bq_schema_out.append(bq_field)
+            continue
+
+        # Try to automatically determine the type based on the arrow conversion.
+        try:
+            arrow_value = pyarrow.array(values)
+            bq_field = (
+                pandas_gbq.schema.pyarrow_to_bigquery.arrow_type_to_bigquery_field(
+                    column,
+                    arrow_value.type,
+                    default_type=default_type,
+                )
+            )
+
+            if bq_field:
+                bq_schema_out.append(bq_field)
+                continue
+        except pyarrow.lib.ArrowInvalid:
+            # TODO(tswast): Better error message if conversion to arrow fails.
+            pass
+
+        # Unknown field type.
+        bq_field = schema.SchemaField(column, default_type)
+        bq_schema_out.append(bq_field)
+        unknown_type_fields.append(bq_field)
+
+    # Append any fields from the BigQuery schema that are not in the
+    # DataFrame.
+    if override_fields_unused:
+        warnings.warn(
+            "Provided BigQuery fields contain field(s) not present in "
+            "DataFrame: {}".format(sorted(override_fields_unused)),
+            UserWarning,
+        )
+        for field_name in sorted(override_fields_unused):
+            bq_schema_out.append(override_fields_by_name[field_name])
+
+    # If schema detection was not successful for all columns, also try with
+    # pyarrow, if available.
+    if unknown_type_fields:
+        msg = "Could not determine the type of columns: {}".format(
+            ", ".join(field.name for field in unknown_type_fields)
+        )
+        warnings.warn(msg)
+
+    return tuple(bq_schema_out)
+
+
+def dtype_to_bigquery_field(name, dtype) -> Optional[schema.SchemaField]:
+    """Infers the BigQuery schema field type from a pandas dtype.
+
+    Args:
+        name (str):
+            Name of the column/field.
+        dtype:
+            A pandas / numpy dtype object.
+
+    Returns:
+        Optional[schema.SchemaField]:
+            The schema field, or None if a type cannot be inferred, such as if
+            it is ambiguous like the object dtype.
+    """
+    bq_type = _PANDAS_DTYPE_TO_BQ.get(dtype.name)
+
+    if bq_type is not None:
+        return schema.SchemaField(name, bq_type)
+
+    if hasattr(pandas, "ArrowDtype") and isinstance(dtype, pandas.ArrowDtype):
+        return pandas_gbq.schema.pyarrow_to_bigquery.arrow_type_to_bigquery_field(
+            name, dtype.pyarrow_dtype
+        )
+
+    return None
+
+
+def value_to_bigquery_field(
+    name: str, value: Any, default_type: Optional[str] = None
+) -> Optional[schema.SchemaField]:
+    """Infers the BigQuery schema field type from a single value.
+
+    Args:
+        name:
+            The name of the field.
+        value:
+            The value to infer the type from. If None, the default type is used
+            if available.
+        default_type:
+            The default field type.  Defaults to None.
+
+    Returns:
+        The schema field, or None if a type cannot be inferred.
+    """
+
+    # Set the SchemaField datatype to the given default_type if the value
+    # being assessed is None.
+    if value is None:
+        return schema.SchemaField(name, default_type)
+
+    # Map from Python types to BigQuery types. This isn't super exhaustive
+    # because we rely more on pyarrow, which can check more than one value to
+    # determine the type.
+    type_mapping = {
+        str: "STRING",
+    }
+
+    # geopandas and shapely are optional dependencies, so only check if those
+    # are installed.
+    if _BaseGeometry is not None:
+        type_mapping[_BaseGeometry] = "GEOGRAPHY"
+
+    for type_, bq_type in type_mapping.items():
+        if isinstance(value, type_):
+            return schema.SchemaField(name, bq_type)
+
+    # For timezone-naive datetimes, the later pyarrow conversion to try and
+    # learn the type add a timezone to such datetimes, causing them to be
+    # recognized as TIMESTAMP type. We thus additionally check the actual data
+    # to see if we need to overrule that and choose DATETIME instead.
+    #
+    # See: https://github.com/googleapis/python-bigquery/issues/985
+    # and https://github.com/googleapis/python-bigquery/pull/1061
+    # and https://github.com/googleapis/python-bigquery-pandas/issues/450
+    if isinstance(value, datetime.datetime):
+        if value.tzinfo is not None:
+            return schema.SchemaField(name, "TIMESTAMP")
+        else:
+            return schema.SchemaField(name, "DATETIME")
+
+    return None
+
+
+def values_to_bigquery_field(
+    name: str, values: Any, default_type: str = "STRING"
+) -> Optional[schema.SchemaField]:
+    """Infers the BigQuery schema field type from a list of values.
+
+    This function iterates through the given values to determine the
+    corresponding schema field type.
+
+    Args:
+        name:
+            The name of the field.
+        values:
+            An iterable of values to infer the type from. If all the values
+            are None or the iterable is empty, the function returns None.
+        default_type:
+            The default field type to use if a specific type cannot be
+            determined from the values. Defaults to "STRING".
+
+    Returns:
+        The schema field, or None if a type cannot be inferred.
+    """
+    value = pandas_gbq.core.pandas.first_valid(values)
+
+    # All values came back as NULL, thus type not determinable by this method.
+    # Return None so we can try other methods.
+    if value is None:
+        return None
+
+    field = value_to_bigquery_field(name, value, default_type=default_type)
+    if field:
+        return field
+
+    # Check plain ARRAY values here. Exclude mapping types to let STRUCT get
+    # determined by pyarrow, which can examine more values to determine all
+    # keys.
+    if isinstance(value, collections.abc.Iterable) and not isinstance(
+        value, collections.abc.Mapping
+    ):
+        # It could be that this value contains all None or is empty, so get the
+        # first non-None value we can find.
+        valid_item = pandas_gbq.core.pandas.first_array_valid(values)
+        field = value_to_bigquery_field(name, valid_item, default_type=default_type)
+
+        if field is not None:
+            return schema.SchemaField(name, field.field_type, mode="REPEATED")
+
+    return None
diff --git a/packages/pandas-gbq/pandas_gbq/schema/pyarrow_to_bigquery.py b/packages/pandas-gbq/pandas_gbq/schema/pyarrow_to_bigquery.py
new file mode 100644
index 000000000000..d917499fe079
--- /dev/null
+++ b/packages/pandas-gbq/pandas_gbq/schema/pyarrow_to_bigquery.py
@@ -0,0 +1,134 @@
+# Copyright (c) 2023 pandas-gbq Authors All rights reserved.
+# Use of this source code is governed by a BSD-style
+# license that can be found in the LICENSE file.
+
+from typing import Optional, cast
+
+from google.cloud.bigquery import schema
+import pyarrow
+import pyarrow.types
+
+_ARROW_SCALAR_IDS_TO_BQ = {
+    # https://arrow.apache.org/docs/python/api/datatypes.html#type-classes
+    pyarrow.bool_().id: "BOOLEAN",
+    pyarrow.int8().id: "INTEGER",
+    pyarrow.int16().id: "INTEGER",
+    pyarrow.int32().id: "INTEGER",
+    pyarrow.int64().id: "INTEGER",
+    pyarrow.uint8().id: "INTEGER",
+    pyarrow.uint16().id: "INTEGER",
+    pyarrow.uint32().id: "INTEGER",
+    pyarrow.uint64().id: "INTEGER",
+    pyarrow.float16().id: "FLOAT",
+    pyarrow.float32().id: "FLOAT",
+    pyarrow.float64().id: "FLOAT",
+    pyarrow.time32("ms").id: "TIME",
+    pyarrow.time64("ns").id: "TIME",
+    pyarrow.timestamp("ns").id: "TIMESTAMP",
+    pyarrow.date32().id: "DATE",
+    pyarrow.date64().id: "DATETIME",  # because millisecond resolution
+    pyarrow.binary().id: "BYTES",
+    pyarrow.string().id: "STRING",  # also alias for pyarrow.utf8()
+    pyarrow.large_string().id: "STRING",
+    # The exact decimal's scale and precision are not important, as only
+    # the type ID matters, and it's the same for all decimal256 instances.
+    pyarrow.decimal128(38, scale=9).id: "NUMERIC",
+    pyarrow.decimal256(76, scale=38).id: "BIGNUMERIC",
+}
+
+
+def arrow_type_to_bigquery_field(
+    name, type_, default_type="STRING"
+) -> Optional[schema.SchemaField]:
+    """Infers the BigQuery schema field type from an arrow type.
+
+    Args:
+        name (str):
+            Name of the column/field.
+        type_:
+            A pyarrow type object.
+
+    Returns:
+        Optional[schema.SchemaField]:
+            The schema field, or None if a type cannot be inferred, such as if
+            it is a type that doesn't have a clear mapping in BigQuery.
+
+            null() are assumed to be the ``default_type``, since there are no
+            values that contradict that.
+    """
+    # If a sub-field is the null type, then assume it's the default type, as
+    # that's the best we can do.
+    # https://github.com/googleapis/python-bigquery-pandas/issues/836
+    if pyarrow.types.is_null(type_):
+        return schema.SchemaField(name, default_type)
+
+    # Since both TIMESTAMP/DATETIME use pyarrow.timestamp(...), we need to use
+    # a special case to disambiguate them. See:
+    # https://github.com/googleapis/python-bigquery-pandas/issues/450
+    if pyarrow.types.is_timestamp(type_):
+        if type_.tz is None:
+            return schema.SchemaField(name, "DATETIME")
+        else:
+            return schema.SchemaField(name, "TIMESTAMP")
+
+    detected_type = _ARROW_SCALAR_IDS_TO_BQ.get(type_.id, None)
+
+    # We need a special case for values that might fit in Arrow decimal128 but
+    # not with the scale/precision that is used in BigQuery's NUMERIC type.
+    # See: https://github.com/googleapis/python-bigquery/issues/1650
+    if detected_type == "NUMERIC" and type_.scale > 9:
+        detected_type = "BIGNUMERIC"
+
+    if detected_type is not None:
+        return schema.SchemaField(name, detected_type)
+
+    if pyarrow.types.is_list(type_):
+        return arrow_list_type_to_bigquery(name, type_, default_type=default_type)
+
+    if pyarrow.types.is_struct(type_):
+        inner_fields: list[pyarrow.Field] = []
+        struct_type = cast(pyarrow.StructType, type_)
+        for field_index in range(struct_type.num_fields):
+            field = struct_type[field_index]
+            inner_fields.append(
+                arrow_type_to_bigquery_field(
+                    field.name, field.type, default_type=default_type
+                )
+            )
+
+        return schema.SchemaField(name, "RECORD", fields=inner_fields)
+
+    return None
+
+
+def arrow_list_type_to_bigquery(
+    name, type_, default_type="STRING"
+) -> Optional[schema.SchemaField]:
+    """Infers the BigQuery schema field type from an arrow list type.
+
+    Args:
+        name (str):
+            Name of the column/field.
+        type_:
+            A pyarrow type object.
+
+    Returns:
+        Optional[schema.SchemaField]:
+            The schema field, or None if a type cannot be inferred, such as if
+            it is a type that doesn't have a clear mapping in BigQuery.
+
+            null() are assumed to be the ``default_type``, since there are no
+            values that contradict that.
+    """
+    inner_field = arrow_type_to_bigquery_field(
+        name, type_.value_type, default_type=default_type
+    )
+
+    # If this is None, it means we got some type that we can't cleanly map to
+    # a BigQuery type, so bubble that status up.
+    if inner_field is None:
+        return None
+
+    return schema.SchemaField(
+        name, inner_field.field_type, mode="REPEATED", fields=inner_field.fields
+    )
diff --git a/packages/pandas-gbq/pandas_gbq/timestamp.py b/packages/pandas-gbq/pandas_gbq/timestamp.py
new file mode 100644
index 000000000000..66374881dae6
--- /dev/null
+++ b/packages/pandas-gbq/pandas_gbq/timestamp.py
@@ -0,0 +1,45 @@
+# Copyright (c) 2017 pandas-gbq Authors All rights reserved.
+# Use of this source code is governed by a BSD-style
+# license that can be found in the LICENSE file.
+
+"""Helpers for working with TIMESTAMP data type.
+
+Private module.
+"""
+
+import pandas.api.types
+
+
+def localize_df(df, schema_fields):
+    """Localize any TIMESTAMP columns to tz-aware type.
+
+    In pandas versions before 0.24.0, DatetimeTZDtype cannot be used as the
+    dtype in Series/DataFrame construction, so localize those columns after
+    the DataFrame is constructed.
+
+    Parameters
+    ----------
+    schema_fields: sequence of dict
+        BigQuery schema in parsed JSON data format.
+    df: pandaas.DataFrame
+        DataFrame in which to localize TIMESTAMP columns.
+
+
+    Returns
+    -------
+    pandas.DataFrame
+        DataFrame with localized TIMESTAMP columns.
+    """
+    for field in schema_fields:
+        column = str(field["name"])
+        if "mode" in field and field["mode"].upper() == "REPEATED":
+            continue
+
+        if (
+            field["type"].upper() == "TIMESTAMP"
+            and pandas.api.types.is_datetime64_ns_dtype(df.dtypes[column])
+            and df[column].dt.tz is None
+        ):
+            df[column] = df[column].dt.tz_localize("UTC")
+
+    return df
diff --git a/packages/pandas-gbq/pandas_gbq/version.py b/packages/pandas-gbq/pandas_gbq/version.py
new file mode 100644
index 000000000000..157b6a5699ae
--- /dev/null
+++ b/packages/pandas-gbq/pandas_gbq/version.py
@@ -0,0 +1,5 @@
+# Copyright (c) 2021 pandas-gbq Authors All rights reserved.
+# Use of this source code is governed by a BSD-style
+# license that can be found in the LICENSE file.
+
+__version__ = "0.31.0"
diff --git a/packages/pandas-gbq/release-procedure.md b/packages/pandas-gbq/release-procedure.md
new file mode 100644
index 000000000000..47c8fd74fe7a
--- /dev/null
+++ b/packages/pandas-gbq/release-procedure.md
@@ -0,0 +1,38 @@
+
+*   Send PR to prepare release on scheduled date.
+
+*   Verify your local repository is on the latest changes. `rebase -i` should be noop.
+
+        git fetch pandas-gbq master
+        git checkout master
+        git rebase -i pandas-gbq/master
+        git diff pandas-gbq/master
+
+*   Tag commit
+
+        git tag -a x.x.x -m 'Version x.x.x'
+
+*   Push to GitHub
+
+        git push pandas-gbq master --tags
+
+*   Build the package
+
+        git clean -xfd
+        python setup.py register sdist bdist_wheel
+
+*   Upload to test PyPI
+
+        twine upload --repository testpypi dist/*
+
+*   Try out test PyPI package
+
+        pip install --upgrade --index-url https://test.pypi.org/simple/ --extra-index-url https://pypi.org/simple pandas-gbq
+
+*   Upload to PyPI
+
+        twine upload dist/*
+
+*   Create the [release on GitHub](https://github.com/googleapis/python-bigquery-pandas/releases/new) using the tag created earlier.
+
+    *   Upload wheel and source zip from `dist/` directory.
diff --git a/packages/pandas-gbq/renovate.json b/packages/pandas-gbq/renovate.json
new file mode 100644
index 000000000000..9d9a6d0bb8cc
--- /dev/null
+++ b/packages/pandas-gbq/renovate.json
@@ -0,0 +1,12 @@
+{
+  "extends": [
+    "config:base",
+    "group:all",
+    ":preserveSemverRanges",
+    ":disableDependencyDashboard"
+  ],
+  "ignorePaths": [".pre-commit-config.yaml", ".kokoro/requirements.txt", "setup.py", ".github/workflows/unittest.yml", ".github/workflows/docs.yml", ".github/workflows/lint.yml"],
+  "pip_requirements": {
+    "fileMatch": ["requirements-test.txt", "samples/[\\S/]*constraints.txt", "samples/[\\S/]*constraints-test.txt"]
+  }
+}
diff --git a/packages/pandas-gbq/requirements-dev.txt b/packages/pandas-gbq/requirements-dev.txt
new file mode 100644
index 000000000000..e0e72d7fa5a9
--- /dev/null
+++ b/packages/pandas-gbq/requirements-dev.txt
@@ -0,0 +1,6 @@
+flake8
+google-cloud-bigquery
+nox-automation
+pandas
+pytest
+setuptools
diff --git a/packages/pandas-gbq/requirements.txt b/packages/pandas-gbq/requirements.txt
new file mode 100644
index 000000000000..bf23435f2648
--- /dev/null
+++ b/packages/pandas-gbq/requirements.txt
@@ -0,0 +1,5 @@
+pandas
+google-auth
+google-auth-oauthlib
+google-cloud-bigquery
+tqdm
\ No newline at end of file
diff --git a/packages/pandas-gbq/samples/snippets/__init__.py b/packages/pandas-gbq/samples/snippets/__init__.py
new file mode 100644
index 000000000000..c9ab850639a6
--- /dev/null
+++ b/packages/pandas-gbq/samples/snippets/__init__.py
@@ -0,0 +1,3 @@
+# Copyright (c) 2017 pandas-gbq Authors All rights reserved.
+# Use of this source code is governed by a BSD-style
+# license that can be found in the LICENSE file.
diff --git a/packages/pandas-gbq/samples/snippets/conftest.py b/packages/pandas-gbq/samples/snippets/conftest.py
new file mode 100644
index 000000000000..0216c1da504b
--- /dev/null
+++ b/packages/pandas-gbq/samples/snippets/conftest.py
@@ -0,0 +1,38 @@
+# Copyright 2019. PyData Development Team
+# Distributed under BSD 3-Clause License.
+# See LICENSE.txt for details.
+
+from google.cloud import bigquery
+import pytest
+import test_utils.prefixer
+
+prefixer = test_utils.prefixer.Prefixer("python-bigquery-pandas", "samples/snippets")
+
+
+@pytest.fixture(scope="session", autouse=True)
+def cleanup_datasets(bigquery_client: bigquery.Client):
+    for dataset in bigquery_client.list_datasets():
+        if prefixer.should_cleanup(dataset.dataset_id):
+            bigquery_client.delete_dataset(
+                dataset.reference, delete_contents=True, not_found_ok=True
+            )
+
+
+@pytest.fixture(scope="session")
+def bigquery_client() -> bigquery.Client:
+    return bigquery.Client()
+
+
+@pytest.fixture(scope="session")
+def project_id(bigquery_client) -> str:
+    return bigquery_client.project
+
+
+@pytest.fixture(scope="session")
+def dataset_id(bigquery_client: bigquery.Client, project_id: str):
+    dataset_id = prefixer.create_prefix()
+    full_dataset_id = f"{project_id}.{dataset_id}"
+    dataset = bigquery.Dataset(full_dataset_id)
+    bigquery_client.create_dataset(dataset)
+    yield dataset_id
+    bigquery_client.delete_dataset(dataset, delete_contents=True, not_found_ok=True)
diff --git a/packages/pandas-gbq/samples/snippets/noxfile.py b/packages/pandas-gbq/samples/snippets/noxfile.py
new file mode 100644
index 000000000000..782da043299d
--- /dev/null
+++ b/packages/pandas-gbq/samples/snippets/noxfile.py
@@ -0,0 +1,292 @@
+# 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.
+
+from __future__ import print_function
+
+import glob
+import os
+from pathlib import Path
+import sys
+from typing import Callable, Dict, Optional
+
+import nox
+
+# WARNING - WARNING - WARNING - WARNING - WARNING
+# WARNING - WARNING - WARNING - WARNING - WARNING
+#           DO NOT EDIT THIS FILE EVER!
+# WARNING - WARNING - WARNING - WARNING - WARNING
+# WARNING - WARNING - WARNING - WARNING - WARNING
+
+BLACK_VERSION = "black==22.3.0"
+ISORT_VERSION = "isort==5.10.1"
+
+# Copy `noxfile_config.py` to your directory and modify it instead.
+
+# `TEST_CONFIG` dict is a configuration hook that allows users to
+# modify the test configurations. The values here should be in sync
+# with `noxfile_config.py`. Users will copy `noxfile_config.py` into
+# their directory and modify it.
+
+TEST_CONFIG = {
+    # You can opt out from the test for specific Python versions.
+    "ignored_versions": [],
+    # Old samples are opted out of enforcing Python type hints
+    # All new samples should feature them
+    "enforce_type_hints": False,
+    # An envvar key for determining the project id to use. Change it
+    # to 'BUILD_SPECIFIC_GCLOUD_PROJECT' if you want to opt in using a
+    # build specific Cloud project. You can also use your own string
+    # to use your own Cloud project.
+    "gcloud_project_env": "GOOGLE_CLOUD_PROJECT",
+    # 'gcloud_project_env': 'BUILD_SPECIFIC_GCLOUD_PROJECT',
+    # If you need to use a specific version of pip,
+    # change pip_version_override to the string representation
+    # of the version number, for example, "20.2.4"
+    "pip_version_override": None,
+    # A dictionary you want to inject into your test. Don't put any
+    # secrets here. These values will override predefined values.
+    "envs": {},
+}
+
+
+try:
+    # Ensure we can import noxfile_config in the project's directory.
+    sys.path.append(".")
+    from noxfile_config import TEST_CONFIG_OVERRIDE
+except ImportError as e:
+    print("No user noxfile_config found: detail: {}".format(e))
+    TEST_CONFIG_OVERRIDE = {}
+
+# Update the TEST_CONFIG with the user supplied values.
+TEST_CONFIG.update(TEST_CONFIG_OVERRIDE)
+
+
+def get_pytest_env_vars() -> Dict[str, str]:
+    """Returns a dict for pytest invocation."""
+    ret = {}
+
+    # Override the GCLOUD_PROJECT and the alias.
+    env_key = TEST_CONFIG["gcloud_project_env"]
+    # This should error out if not set.
+    ret["GOOGLE_CLOUD_PROJECT"] = os.environ[env_key]
+
+    # Apply user supplied envs.
+    ret.update(TEST_CONFIG["envs"])
+    return ret
+
+
+# DO NOT EDIT - automatically generated.
+# All versions used to test samples.
+ALL_VERSIONS = ["3.7", "3.8", "3.9", "3.10", "3.11", "3.12", "3.13", "3.14"]
+
+# Any default versions that should be ignored.
+IGNORED_VERSIONS = TEST_CONFIG["ignored_versions"]
+
+TESTED_VERSIONS = sorted([v for v in ALL_VERSIONS if v not in IGNORED_VERSIONS])
+
+INSTALL_LIBRARY_FROM_SOURCE = os.environ.get("INSTALL_LIBRARY_FROM_SOURCE", False) in (
+    "True",
+    "true",
+)
+
+# Error if a python version is missing
+nox.options.error_on_missing_interpreters = True
+
+#
+# Style Checks
+#
+
+
+# Linting with flake8.
+#
+# We ignore the following rules:
+#   E203: whitespace before ‘:’
+#   E266: too many leading ‘#’ for block comment
+#   E501: line too long
+#   I202: Additional newline in a section of imports
+#
+# We also need to specify the rules which are ignored by default:
+# ['E226', 'W504', 'E126', 'E123', 'W503', 'E24', 'E704', 'E121']
+FLAKE8_COMMON_ARGS = [
+    "--show-source",
+    "--builtin=gettext",
+    "--max-complexity=20",
+    "--exclude=.nox,.cache,env,lib,generated_pb2,*_pb2.py,*_pb2_grpc.py",
+    "--ignore=E121,E123,E126,E203,E226,E24,E266,E501,E704,W503,W504,I202",
+    "--max-line-length=88",
+]
+
+
+@nox.session
+def lint(session: nox.sessions.Session) -> None:
+    if not TEST_CONFIG["enforce_type_hints"]:
+        session.install("flake8")
+    else:
+        session.install("flake8", "flake8-annotations")
+
+    args = FLAKE8_COMMON_ARGS + [
+        ".",
+    ]
+    session.run("flake8", *args)
+
+
+#
+# Black
+#
+
+
+@nox.session
+def blacken(session: nox.sessions.Session) -> None:
+    """Run black. Format code to uniform standard."""
+    session.install(BLACK_VERSION)
+    python_files = [path for path in os.listdir(".") if path.endswith(".py")]
+
+    session.run("black", *python_files)
+
+
+#
+# format = isort + black
+#
+
+
+@nox.session
+def format(session: nox.sessions.Session) -> None:
+    """
+    Run isort to sort imports. Then run black
+    to format code to uniform standard.
+    """
+    session.install(BLACK_VERSION, ISORT_VERSION)
+    python_files = [path for path in os.listdir(".") if path.endswith(".py")]
+
+    # Use the --fss option to sort imports using strict alphabetical order.
+    # See https://pycqa.github.io/isort/docs/configuration/options.html#force-sort-within-sections
+    session.run("isort", "--fss", *python_files)
+    session.run("black", *python_files)
+
+
+#
+# Sample Tests
+#
+
+
+PYTEST_COMMON_ARGS = ["--junitxml=sponge_log.xml"]
+
+
+def _session_tests(
+    session: nox.sessions.Session, post_install: Callable = None
+) -> None:
+    # check for presence of tests
+    test_list = glob.glob("**/*_test.py", recursive=True) + glob.glob(
+        "**/test_*.py", recursive=True
+    )
+    test_list.extend(glob.glob("**/tests", recursive=True))
+
+    if len(test_list) == 0:
+        print("No tests found, skipping directory.")
+        return
+
+    if TEST_CONFIG["pip_version_override"]:
+        pip_version = TEST_CONFIG["pip_version_override"]
+        session.install(f"pip=={pip_version}")
+    """Runs py.test for a particular project."""
+    concurrent_args = []
+    if os.path.exists("requirements.txt"):
+        if os.path.exists("constraints.txt"):
+            session.install("-r", "requirements.txt", "-c", "constraints.txt")
+        else:
+            session.install("-r", "requirements.txt")
+        with open("requirements.txt") as rfile:
+            packages = rfile.read()
+
+    if os.path.exists("requirements-test.txt"):
+        if os.path.exists("constraints-test.txt"):
+            session.install("-r", "requirements-test.txt", "-c", "constraints-test.txt")
+        else:
+            session.install("-r", "requirements-test.txt")
+        with open("requirements-test.txt") as rtfile:
+            packages += rtfile.read()
+
+    if INSTALL_LIBRARY_FROM_SOURCE:
+        session.install("-e", _get_repo_root())
+
+    if post_install:
+        post_install(session)
+
+    if "pytest-parallel" in packages:
+        concurrent_args.extend(["--workers", "auto", "--tests-per-worker", "auto"])
+    elif "pytest-xdist" in packages:
+        concurrent_args.extend(["-n", "auto"])
+
+    session.run(
+        "pytest",
+        *(PYTEST_COMMON_ARGS + session.posargs + concurrent_args),
+        # Pytest will return 5 when no tests are collected. This can happen
+        # on travis where slow and flaky tests are excluded.
+        # See http://doc.pytest.org/en/latest/_modules/_pytest/main.html
+        success_codes=[0, 5],
+        env=get_pytest_env_vars(),
+    )
+
+
+@nox.session(python=ALL_VERSIONS)
+def py(session: nox.sessions.Session) -> None:
+    """Runs py.test for a sample using the specified version of Python."""
+    if session.python in TESTED_VERSIONS:
+        _session_tests(session)
+    else:
+        session.skip(
+            "SKIPPED: {} tests are disabled for this sample.".format(session.python)
+        )
+
+
+#
+# Readmegen
+#
+
+
+def _get_repo_root() -> Optional[str]:
+    """Returns the root folder of the project."""
+    # Get root of this repository. Assume we don't have directories nested deeper than 10 items.
+    p = Path(os.getcwd())
+    for i in range(10):
+        if p is None:
+            break
+        if Path(p / ".git").exists():
+            return str(p)
+        # .git is not available in repos cloned via Cloud Build
+        # setup.py is always in the library's root, so use that instead
+        # https://github.com/googleapis/synthtool/issues/792
+        if Path(p / "setup.py").exists():
+            return str(p)
+        p = p.parent
+    raise Exception("Unable to detect repository root.")
+
+
+GENERATED_READMES = sorted([x for x in Path(".").rglob("*.rst.in")])
+
+
+@nox.session
+@nox.parametrize("path", GENERATED_READMES)
+def readmegen(session: nox.sessions.Session, path: str) -> None:
+    """(Re-)generates the readme for a sample."""
+    session.install("jinja2", "pyyaml")
+    dir_ = os.path.dirname(path)
+
+    if os.path.exists(os.path.join(dir_, "requirements.txt")):
+        session.install("-r", os.path.join(dir_, "requirements.txt"))
+
+    in_file = os.path.join(dir_, "README.rst.in")
+    session.run(
+        "python", _get_repo_root() + "/scripts/readme-gen/readme_gen.py", in_file
+    )
diff --git a/packages/pandas-gbq/samples/snippets/noxfile_config.py b/packages/pandas-gbq/samples/snippets/noxfile_config.py
new file mode 100644
index 000000000000..2bceb2fe12fe
--- /dev/null
+++ b/packages/pandas-gbq/samples/snippets/noxfile_config.py
@@ -0,0 +1,7 @@
+# Copyright (c) 2021 pandas-gbq Authors All rights reserved.
+# Use of this source code is governed by a BSD-style
+# license that can be found in the LICENSE file.
+
+TEST_CONFIG_OVERRIDE = {
+    "ignored_versions": ["2.7", "3.6"],
+}
diff --git a/packages/pandas-gbq/samples/snippets/read_gbq_legacy.py b/packages/pandas-gbq/samples/snippets/read_gbq_legacy.py
new file mode 100644
index 000000000000..ed2e4f408f27
--- /dev/null
+++ b/packages/pandas-gbq/samples/snippets/read_gbq_legacy.py
@@ -0,0 +1,35 @@
+# Copyright 2019. PyData Development Team
+# Distributed under BSD 3-Clause License.
+# See LICENSE.txt for details.
+
+"""Simple query example."""
+
+import argparse
+
+import pandas_gbq
+
+
+def main(project_id):
+    # [START bigquery_pandas_gbq_read_gbq_legacy]
+    sql = """
+    SELECT country_name, alpha_2_code
+    FROM [bigquery-public-data:utility_us.country_code_iso]
+    WHERE alpha_2_code LIKE 'Z%'
+    """
+    df = pandas_gbq.read_gbq(
+        sql,
+        project_id=project_id,
+        # Set the dialect to "legacy" to use legacy SQL syntax. As of
+        # pandas-gbq version 0.10.0, the default dialect is "standard".
+        dialect="legacy",
+    )
+    # [END bigquery_pandas_gbq_read_gbq_legacy]
+    print(df)
+    return df
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("project_id")
+    args = parser.parse_args()
+    main(args.project_id)
diff --git a/packages/pandas-gbq/samples/snippets/read_gbq_simple.py b/packages/pandas-gbq/samples/snippets/read_gbq_simple.py
new file mode 100644
index 000000000000..a7426745bd3f
--- /dev/null
+++ b/packages/pandas-gbq/samples/snippets/read_gbq_simple.py
@@ -0,0 +1,32 @@
+# Copyright 2019. PyData Development Team
+# Distributed under BSD 3-Clause License.
+# See LICENSE.txt for details.
+
+"""Simple query example."""
+
+import argparse
+
+
+def main(project_id):
+    # [START bigquery_pandas_gbq_read_gbq_simple]
+    import pandas_gbq
+
+    # TODO: Set project_id to your Google Cloud Platform project ID.
+    # project_id = "my-project"
+
+    sql = """
+    SELECT country_name, alpha_2_code
+    FROM `bigquery-public-data.utility_us.country_code_iso`
+    WHERE alpha_2_code LIKE 'A%'
+    """
+    df = pandas_gbq.read_gbq(sql, project_id=project_id)
+    # [END bigquery_pandas_gbq_read_gbq_simple]
+    print(df)
+    return df
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("project_id")
+    args = parser.parse_args()
+    main(args.project_id)
diff --git a/packages/pandas-gbq/samples/snippets/read_gbq_test.py b/packages/pandas-gbq/samples/snippets/read_gbq_test.py
new file mode 100644
index 000000000000..4fc8cb7b9d1f
--- /dev/null
+++ b/packages/pandas-gbq/samples/snippets/read_gbq_test.py
@@ -0,0 +1,21 @@
+# Copyright 2019. PyData Development Team
+# Distributed under BSD 3-Clause License.
+# See LICENSE.txt for details.
+
+"""System tests for read_gbq code samples."""
+
+from . import read_gbq_legacy, read_gbq_simple
+
+
+def test_read_gbq_legacy(project_id):
+    df = read_gbq_legacy.main(project_id)
+    assert df is not None
+    assert "ZA" in df["alpha_2_code"].values
+    assert "South Africa" in df["country_name"].values
+
+
+def test_read_gbq_simple(project_id):
+    df = read_gbq_simple.main(project_id)
+    assert df is not None
+    assert "AU" in df["alpha_2_code"].values
+    assert "Australia" in df["country_name"].values
diff --git a/packages/pandas-gbq/samples/snippets/requirements-test.txt b/packages/pandas-gbq/samples/snippets/requirements-test.txt
new file mode 100644
index 000000000000..4ad485fb3da5
--- /dev/null
+++ b/packages/pandas-gbq/samples/snippets/requirements-test.txt
@@ -0,0 +1,2 @@
+google-cloud-testutils==1.6.4
+pytest==8.4.2
diff --git a/packages/pandas-gbq/samples/snippets/requirements.txt b/packages/pandas-gbq/samples/snippets/requirements.txt
new file mode 100644
index 000000000000..3aba0be3f54d
--- /dev/null
+++ b/packages/pandas-gbq/samples/snippets/requirements.txt
@@ -0,0 +1,6 @@
+google-cloud-bigquery-storage==2.33.1
+google-cloud-bigquery==3.38.0
+pandas-gbq==0.29.2
+pandas==2.3.3
+pyarrow==21.0.0; python_version <= "3.9"
+pyarrow==22.0.0; python_version > "3.9"
diff --git a/packages/pandas-gbq/samples/snippets/to_gbq_simple.py b/packages/pandas-gbq/samples/snippets/to_gbq_simple.py
new file mode 100644
index 000000000000..7330e2e06bf5
--- /dev/null
+++ b/packages/pandas-gbq/samples/snippets/to_gbq_simple.py
@@ -0,0 +1,41 @@
+# Copyright 2019. PyData Development Team
+# Distributed under BSD 3-Clause License.
+# See LICENSE.txt for details.
+
+"""Simple upload example."""
+
+import argparse
+
+
+def main(project_id, table_id):
+    # [START bigquery_pandas_gbq_to_gbq_simple]
+    import pandas
+    import pandas_gbq
+
+    # TODO: Set project_id to your Google Cloud Platform project ID.
+    # project_id = "my-project"
+    # TODO: Set table_id to the full destination table ID (including the
+    #       dataset ID).
+    # table_id = 'my_dataset.my_table'
+
+    df = pandas.DataFrame(
+        {
+            "my_string": ["a", "b", "c"],
+            "my_int64": [1, 2, 3],
+            "my_float64": [4.0, 5.0, 6.0],
+            "my_bool1": [True, False, True],
+            "my_bool2": [False, True, False],
+            "my_dates": pandas.date_range("now", periods=3),
+        }
+    )
+
+    pandas_gbq.to_gbq(df, table_id, project_id=project_id)
+    # [END bigquery_pandas_gbq_to_gbq_simple]
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("project_id")
+    parser.add_argument("table_id")
+    args = parser.parse_args()
+    main(args.project_id, args.table_id)
diff --git a/packages/pandas-gbq/samples/snippets/to_gbq_test.py b/packages/pandas-gbq/samples/snippets/to_gbq_test.py
new file mode 100644
index 000000000000..6db15522a46b
--- /dev/null
+++ b/packages/pandas-gbq/samples/snippets/to_gbq_test.py
@@ -0,0 +1,16 @@
+# Copyright 2019. PyData Development Team
+# Distributed under BSD 3-Clause License.
+# See LICENSE.txt for details.
+
+"""System tests for to_gbq code samples."""
+
+import random
+
+from . import to_gbq_simple
+
+
+def test_to_gbq_simple(project_id, bigquery_client, dataset_id):
+    table_id = f"{dataset_id}.to_gbq_simple_{random.randint(0, 999999)}"
+    to_gbq_simple.main(project_id, table_id)
+    table = bigquery_client.get_table(table_id)
+    assert table.num_rows == 3
diff --git a/packages/pandas-gbq/scripts/decrypt-secrets.sh b/packages/pandas-gbq/scripts/decrypt-secrets.sh
new file mode 100755
index 000000000000..120b0ddc4364
--- /dev/null
+++ b/packages/pandas-gbq/scripts/decrypt-secrets.sh
@@ -0,0 +1,46 @@
+#!/bin/bash
+
+# Copyright 2024 Google LLC All rights reserved.
+#
+# 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.
+
+DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
+ROOT=$( dirname "$DIR" )
+
+# Work from the project root.
+cd $ROOT
+
+# Prevent it from overriding files.
+# We recommend that sample authors use their own service account files and cloud project.
+# In that case, they are supposed to prepare these files by themselves.
+if [[ -f "testing/test-env.sh" ]] || \
+       [[ -f "testing/service-account.json" ]] || \
+       [[ -f "testing/client-secrets.json" ]]; then
+    echo "One or more target files exist, aborting."
+    exit 1
+fi
+
+# Use SECRET_MANAGER_PROJECT if set, fallback to cloud-devrel-kokoro-resources.
+PROJECT_ID="${SECRET_MANAGER_PROJECT:-cloud-devrel-kokoro-resources}"
+
+gcloud secrets versions access latest --secret="python-docs-samples-test-env" \
+       --project="${PROJECT_ID}" \
+       > testing/test-env.sh
+gcloud secrets versions access latest \
+       --secret="python-docs-samples-service-account" \
+       --project="${PROJECT_ID}" \
+       > testing/service-account.json
+gcloud secrets versions access latest \
+       --secret="python-docs-samples-client-secrets" \
+       --project="${PROJECT_ID}" \
+       > testing/client-secrets.json
diff --git a/packages/pandas-gbq/scripts/readme-gen/readme_gen.py b/packages/pandas-gbq/scripts/readme-gen/readme_gen.py
new file mode 100644
index 000000000000..8f5e248a0da1
--- /dev/null
+++ b/packages/pandas-gbq/scripts/readme-gen/readme_gen.py
@@ -0,0 +1,69 @@
+#!/usr/bin/env python
+
+# 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
+#
+#      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.
+
+"""Generates READMEs using configuration defined in yaml."""
+
+import argparse
+import io
+import os
+import subprocess
+
+import jinja2
+import yaml
+
+
+jinja_env = jinja2.Environment(
+    trim_blocks=True,
+    loader=jinja2.FileSystemLoader(
+        os.path.abspath(os.path.join(os.path.dirname(__file__), "templates"))
+    ),
+    autoescape=True,
+)
+
+README_TMPL = jinja_env.get_template("README.tmpl.rst")
+
+
+def get_help(file):
+    return subprocess.check_output(["python", file, "--help"]).decode()
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("source")
+    parser.add_argument("--destination", default="README.rst")
+
+    args = parser.parse_args()
+
+    source = os.path.abspath(args.source)
+    root = os.path.dirname(source)
+    destination = os.path.join(root, args.destination)
+
+    jinja_env.globals["get_help"] = get_help
+
+    with io.open(source, "r") as f:
+        config = yaml.load(f)
+
+    # This allows get_help to execute in the right directory.
+    os.chdir(root)
+
+    output = README_TMPL.render(config)
+
+    with io.open(destination, "w") as f:
+        f.write(output)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/packages/pandas-gbq/scripts/readme-gen/templates/README.tmpl.rst b/packages/pandas-gbq/scripts/readme-gen/templates/README.tmpl.rst
new file mode 100644
index 000000000000..4fd239765b0a
--- /dev/null
+++ b/packages/pandas-gbq/scripts/readme-gen/templates/README.tmpl.rst
@@ -0,0 +1,87 @@
+{# The following line is a lie. BUT! Once jinja2 is done with it, it will
+    become truth! #}
+.. This file is automatically generated. Do not edit this file directly.
+
+{{product.name}} Python Samples
+===============================================================================
+
+.. image:: https://gstatic.com/cloudssh/images/open-btn.png
+   :target: https://console.cloud.google.com/cloudshell/open?git_repo=https://github.com/GoogleCloudPlatform/python-docs-samples&page=editor&open_in_editor={{folder}}/README.rst
+
+
+This directory contains samples for {{product.name}}. {{product.description}}
+
+{{description}}
+
+.. _{{product.name}}: {{product.url}}
+
+{% if required_api_url %}
+To run the sample, you need to enable the API at: {{required_api_url}}
+{% endif %}
+
+{% if required_role %}
+To run the sample, you need to have `{{required_role}}` role.
+{% endif %}
+
+{{other_required_steps}}
+
+{% if setup %}
+Setup
+-------------------------------------------------------------------------------
+
+{% for section in setup %}
+
+{% include section + '.tmpl.rst' %}
+
+{% endfor %}
+{% endif %}
+
+{% if samples %}
+Samples
+-------------------------------------------------------------------------------
+
+{% for sample in samples %}
+{{sample.name}}
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+{% if not sample.hide_cloudshell_button %}
+.. image:: https://gstatic.com/cloudssh/images/open-btn.png
+   :target: https://console.cloud.google.com/cloudshell/open?git_repo=https://github.com/GoogleCloudPlatform/python-docs-samples&page=editor&open_in_editor={{folder}}/{{sample.file}},{{folder}}/README.rst
+{% endif %}
+
+
+{{sample.description}}
+
+To run this sample:
+
+.. code-block:: bash
+
+    $ python {{sample.file}}
+{% if sample.show_help %}
+
+    {{get_help(sample.file)|indent}}
+{% endif %}
+
+
+{% endfor %}
+{% endif %}
+
+{% if cloud_client_library %}
+
+The client library
+-------------------------------------------------------------------------------
+
+This sample uses the `Google Cloud Client Library for Python`_.
+You can read the documentation for more details on API usage and use GitHub
+to `browse the source`_ and  `report issues`_.
+
+.. _Google Cloud Client Library for Python:
+    https://googlecloudplatform.github.io/google-cloud-python/
+.. _browse the source:
+    https://github.com/GoogleCloudPlatform/google-cloud-python
+.. _report issues:
+    https://github.com/GoogleCloudPlatform/google-cloud-python/issues
+
+{% endif %}
+
+.. _Google Cloud SDK: https://cloud.google.com/sdk/
\ No newline at end of file
diff --git a/packages/pandas-gbq/scripts/readme-gen/templates/auth.tmpl.rst b/packages/pandas-gbq/scripts/readme-gen/templates/auth.tmpl.rst
new file mode 100644
index 000000000000..1446b94a5e3a
--- /dev/null
+++ b/packages/pandas-gbq/scripts/readme-gen/templates/auth.tmpl.rst
@@ -0,0 +1,9 @@
+Authentication
+++++++++++++++
+
+This sample requires you to have authentication setup. Refer to the
+`Authentication Getting Started Guide`_ for instructions on setting up
+credentials for applications.
+
+.. _Authentication Getting Started Guide:
+    https://cloud.google.com/docs/authentication/getting-started
diff --git a/packages/pandas-gbq/scripts/readme-gen/templates/auth_api_key.tmpl.rst b/packages/pandas-gbq/scripts/readme-gen/templates/auth_api_key.tmpl.rst
new file mode 100644
index 000000000000..11957ce2714a
--- /dev/null
+++ b/packages/pandas-gbq/scripts/readme-gen/templates/auth_api_key.tmpl.rst
@@ -0,0 +1,14 @@
+Authentication
+++++++++++++++
+
+Authentication for this service is done via an `API Key`_. To obtain an API
+Key:
+
+1. Open the `Cloud Platform Console`_
+2. Make sure that billing is enabled for your project.
+3. From the **Credentials** page, create a new **API Key** or use an existing
+   one for your project.
+
+.. _API Key:
+    https://developers.google.com/api-client-library/python/guide/aaa_apikeys
+.. _Cloud Console: https://console.cloud.google.com/project?_
diff --git a/packages/pandas-gbq/scripts/readme-gen/templates/install_deps.tmpl.rst b/packages/pandas-gbq/scripts/readme-gen/templates/install_deps.tmpl.rst
new file mode 100644
index 000000000000..6f069c6c87a5
--- /dev/null
+++ b/packages/pandas-gbq/scripts/readme-gen/templates/install_deps.tmpl.rst
@@ -0,0 +1,29 @@
+Install Dependencies
+++++++++++++++++++++
+
+#. Clone python-docs-samples and change directory to the sample directory you want to use.
+
+    .. code-block:: bash
+
+        $ git clone https://github.com/GoogleCloudPlatform/python-docs-samples.git
+
+#. Install `pip`_ and `virtualenv`_ if you do not already have them. You may want to refer to the `Python Development Environment Setup Guide`_ for Google Cloud Platform for instructions.
+
+   .. _Python Development Environment Setup Guide:
+       https://cloud.google.com/python/setup
+
+#. Create a virtualenv. Samples are compatible with Python 3.7+.
+
+    .. code-block:: bash
+
+        $ virtualenv env
+        $ source env/bin/activate
+
+#. Install the dependencies needed to run the samples.
+
+    .. code-block:: bash
+
+        $ pip install -r requirements.txt
+
+.. _pip: https://pip.pypa.io/
+.. _virtualenv: https://virtualenv.pypa.io/
diff --git a/packages/pandas-gbq/scripts/readme-gen/templates/install_portaudio.tmpl.rst b/packages/pandas-gbq/scripts/readme-gen/templates/install_portaudio.tmpl.rst
new file mode 100644
index 000000000000..5ea33d18c00c
--- /dev/null
+++ b/packages/pandas-gbq/scripts/readme-gen/templates/install_portaudio.tmpl.rst
@@ -0,0 +1,35 @@
+Install PortAudio
++++++++++++++++++
+
+Install `PortAudio`_. This is required by the `PyAudio`_ library to stream
+audio from your computer's microphone. PyAudio depends on PortAudio for cross-platform compatibility, and is installed differently depending on the
+platform.
+
+* For Mac OS X, you can use `Homebrew`_::
+
+      brew install portaudio
+
+  **Note**: if you encounter an error when running `pip install` that indicates
+  it can't find `portaudio.h`, try running `pip install` with the following
+  flags::
+
+      pip install --global-option='build_ext' \
+          --global-option='-I/usr/local/include' \
+          --global-option='-L/usr/local/lib' \
+          pyaudio
+
+* For Debian / Ubuntu Linux::
+
+      apt-get install portaudio19-dev python-all-dev
+
+* Windows may work without having to install PortAudio explicitly (it will get
+  installed with PyAudio).
+
+For more details, see the `PyAudio installation`_ page.
+
+
+.. _PyAudio: https://people.csail.mit.edu/hubert/pyaudio/
+.. _PortAudio: http://www.portaudio.com/
+.. _PyAudio installation:
+  https://people.csail.mit.edu/hubert/pyaudio/#downloads
+.. _Homebrew: http://brew.sh
diff --git a/packages/pandas-gbq/setup.py b/packages/pandas-gbq/setup.py
new file mode 100644
index 000000000000..8b1e0260b2e0
--- /dev/null
+++ b/packages/pandas-gbq/setup.py
@@ -0,0 +1,105 @@
+#!/usr/bin/env python
+# Copyright (c) 2017 pandas-gbq Authors All rights reserved.
+# Use of this source code is governed by a BSD-style
+# license that can be found in the LICENSE file.
+
+# -*- coding: utf-8 -*-
+
+import io
+import os
+
+import setuptools
+
+# Package metadata.
+
+name = "pandas-gbq"
+description = "Google BigQuery connector for pandas"
+
+# Should be one of:
+# 'Development Status :: 3 - Alpha'
+# 'Development Status :: 4 - Beta'
+# 'Development Status :: 5 - Production/Stable'
+release_status = "Development Status :: 4 - Beta"
+dependencies = [
+    "setuptools",
+    "db-dtypes >=1.0.4,<2.0.0",
+    "numpy >=1.18.1",
+    "pandas >=1.1.4",
+    "pyarrow >=4.0.0",
+    "pydata-google-auth >=1.5.0",
+    "psutil >=5.9.8",
+    # Note: google-api-core and google-auth are also included via transitive
+    # dependency on google-cloud-bigquery, but this library also uses them
+    # directly.
+    "google-api-core >= 2.15.0, <3.0.0",
+    "google-auth >=2.14.1",
+    "google-auth-oauthlib >=0.7.0",
+    # Please also update the minimum version in pandas_gbq/features.py to
+    # allow pandas-gbq to detect invalid package versions at runtime.
+    "google-cloud-bigquery >=3.20.0,<4.0.0",
+    "packaging >=22.0.0",
+]
+extras = {
+    "bqstorage": [
+        "google-cloud-bigquery-storage >=2.16.2, <3.0.0",
+    ],
+    "tqdm": ["tqdm>=4.23.0"],
+    "geopandas": ["geopandas>=0.9.0", "Shapely>=1.8.4"],
+}
+
+# Setup boilerplate below this line.
+
+package_root = os.path.abspath(os.path.dirname(__file__))
+
+readme_filename = os.path.join(package_root, "README.rst")
+with io.open(readme_filename, encoding="utf-8") as readme_file:
+    readme = readme_file.read()
+
+version = {}
+with open(os.path.join(package_root, "pandas_gbq/version.py")) as fp:
+    exec(fp.read(), version)
+version = version["__version__"]
+
+# Only include packages under the 'google' namespace. Do not include tests,
+# benchmarks, etc.
+packages = [
+    package
+    for package in setuptools.find_namespace_packages()
+    if package.startswith("pandas_gbq")
+]
+
+
+setuptools.setup(
+    name=name,
+    version=version,
+    description=description,
+    long_description=readme,
+    author="pandas-gbq authors",
+    author_email="googleapis-packages@google.com",
+    license="BSD-3-Clause",
+    url="https://github.com/googleapis/python-bigquery-pandas",
+    classifiers=[
+        release_status,
+        "Intended Audience :: Developers",
+        "Intended Audience :: Science/Research",
+        "Operating System :: OS Independent",
+        "License :: OSI Approved :: BSD License",
+        "Programming Language :: Python",
+        "Programming Language :: Python :: 3",
+        "Programming Language :: Python :: 3.9",
+        "Programming Language :: Python :: 3.10",
+        "Programming Language :: Python :: 3.11",
+        "Programming Language :: Python :: 3.12",
+        "Programming Language :: Python :: 3.13",
+        "Operating System :: OS Independent",
+        "Topic :: Internet",
+        "Topic :: Scientific/Engineering",
+    ],
+    platforms="Posix; MacOS X; Windows",
+    packages=packages,
+    install_requires=dependencies,
+    extras_require=extras,
+    python_requires=">=3.9",
+    include_package_data=True,
+    zip_safe=False,
+)
diff --git a/packages/pandas-gbq/testing/.gitignore b/packages/pandas-gbq/testing/.gitignore
new file mode 100644
index 000000000000..b05fbd630881
--- /dev/null
+++ b/packages/pandas-gbq/testing/.gitignore
@@ -0,0 +1,3 @@
+test-env.sh
+service-account.json
+client-secrets.json
\ No newline at end of file
diff --git a/packages/pandas-gbq/testing/constraints-3.10.txt b/packages/pandas-gbq/testing/constraints-3.10.txt
new file mode 100644
index 000000000000..e69de29bb2d1
diff --git a/packages/pandas-gbq/testing/constraints-3.11.txt b/packages/pandas-gbq/testing/constraints-3.11.txt
new file mode 100644
index 000000000000..e69de29bb2d1
diff --git a/packages/pandas-gbq/testing/constraints-3.12.txt b/packages/pandas-gbq/testing/constraints-3.12.txt
new file mode 100644
index 000000000000..e69de29bb2d1
diff --git a/packages/pandas-gbq/testing/constraints-3.13.txt b/packages/pandas-gbq/testing/constraints-3.13.txt
new file mode 100644
index 000000000000..e69de29bb2d1
diff --git a/packages/pandas-gbq/testing/constraints-3.9.txt b/packages/pandas-gbq/testing/constraints-3.9.txt
new file mode 100644
index 000000000000..aff46b2823db
--- /dev/null
+++ b/packages/pandas-gbq/testing/constraints-3.9.txt
@@ -0,0 +1,23 @@
+# This constraints file is used to check that lower bounds
+# are correct in setup.py
+# List *all* library dependencies and extras in this file.
+# Pin the version to the lower bound.
+#
+# e.g., if setup.py has "foo >= 1.14.0, < 2.0.0dev",
+# Then this file should have foo==1.14.0
+db-dtypes==1.0.4
+numpy==1.19.4
+pandas==1.1.4
+psutil==5.9.8
+pyarrow==4.0.0
+pydata-google-auth==1.5.0
+google-api-core==2.15.0
+google-auth==2.14.1
+google-auth-oauthlib==0.7.0
+google-cloud-bigquery==3.20.0
+packaging==22.0.0
+# Extras
+google-cloud-bigquery-storage==2.16.2
+tqdm==4.23.0
+geopandas==0.9.0
+Shapely==1.8.4
diff --git a/packages/pandas-gbq/tests/data/dummy_key.json b/packages/pandas-gbq/tests/data/dummy_key.json
new file mode 100644
index 000000000000..25e17b78c76c
--- /dev/null
+++ b/packages/pandas-gbq/tests/data/dummy_key.json
@@ -0,0 +1,5 @@
+
+    {
+        "private_key": "some_key",
+        "client_email": "service-account@example.com"
+    }
\ No newline at end of file
diff --git a/packages/pandas-gbq/tests/system/__init__.py b/packages/pandas-gbq/tests/system/__init__.py
new file mode 100644
index 000000000000..c9ab850639a6
--- /dev/null
+++ b/packages/pandas-gbq/tests/system/__init__.py
@@ -0,0 +1,3 @@
+# Copyright (c) 2017 pandas-gbq Authors All rights reserved.
+# Use of this source code is governed by a BSD-style
+# license that can be found in the LICENSE file.
diff --git a/packages/pandas-gbq/tests/system/conftest.py b/packages/pandas-gbq/tests/system/conftest.py
new file mode 100644
index 000000000000..c761276d190e
--- /dev/null
+++ b/packages/pandas-gbq/tests/system/conftest.py
@@ -0,0 +1,171 @@
+# Copyright (c) 2017 pandas-gbq Authors All rights reserved.
+# Use of this source code is governed by a BSD-style
+# license that can be found in the LICENSE file.
+
+import functools
+import os
+import pathlib
+
+from google.cloud import bigquery
+import pytest
+import test_utils.prefixer
+
+prefixer = test_utils.prefixer.Prefixer("python-bigquery-pandas", "tests/system")
+
+REPO_DIR = pathlib.Path(__file__).parent.parent.parent
+
+
+@pytest.fixture(scope="session", autouse=True)
+def cleanup_datasets(bigquery_client: bigquery.Client):
+    for dataset in bigquery_client.list_datasets():
+        if prefixer.should_cleanup(dataset.dataset_id):
+            bigquery_client.delete_dataset(
+                dataset.reference, delete_contents=True, not_found_ok=True
+            )
+
+
+@pytest.fixture(scope="session")
+def bigquery_client() -> bigquery.Client:
+    project_id = os.getenv("GOOGLE_CLOUD_PROJECT", os.getenv("GBQ_PROJECT_ID"))
+    return bigquery.Client(project=project_id)
+
+
+@pytest.fixture()
+def credentials(bigquery_client):
+    return bigquery_client._credentials
+
+
+@pytest.fixture(scope="session")
+def project_id(bigquery_client) -> str:
+    return bigquery_client.project
+
+
+@pytest.fixture(scope="session")
+def project(project_id):
+    return project_id
+
+
+@pytest.fixture
+def external_table(bigquery_client, random_dataset, project_id):
+    table_id = prefixer.create_prefix()
+    full_table_id = str(random_dataset.table(table_id))
+    table = bigquery.Table(
+        full_table_id,
+        [
+            bigquery.SchemaField("name", "STRING"),
+            bigquery.SchemaField("post_abbr", "STRING"),
+        ],
+    )
+    external_data_configuration = bigquery.ExternalConfig("CSV")
+    csv_options = bigquery.CSVOptions()
+    csv_options.skip_leading_rows = 1
+    external_data_configuration.csv_options = csv_options
+    external_data_configuration.source_uris = [
+        "gs://cloud-samples-data/bigquery/us-states/us-states.csv"
+    ]
+    table.external_data_configuration = external_data_configuration
+    bigquery_client.create_table(table)
+    return full_table_id
+
+
+@pytest.fixture
+def to_gbq(credentials, project_id):
+    import pandas_gbq
+
+    return functools.partial(
+        pandas_gbq.to_gbq, project_id=project_id, credentials=credentials
+    )
+
+
+@pytest.fixture
+def to_gbq_with_bq_client(bigquery_client):
+    import pandas_gbq
+
+    return functools.partial(pandas_gbq.to_gbq, bigquery_client=bigquery_client)
+
+
+@pytest.fixture
+def read_gbq(credentials, project_id):
+    import pandas_gbq
+
+    return functools.partial(
+        pandas_gbq.read_gbq, project_id=project_id, credentials=credentials
+    )
+
+
+@pytest.fixture
+def read_gbq_with_bq_client(bigquery_client):
+    import pandas_gbq
+
+    return functools.partial(pandas_gbq.read_gbq, bigquery_client=bigquery_client)
+
+
+@pytest.fixture()
+def random_dataset_id(bigquery_client: bigquery.Client, project_id: str):
+    dataset_id = prefixer.create_prefix()
+    full_dataset_id = f"{project_id}.{dataset_id}"
+    yield dataset_id
+    bigquery_client.delete_dataset(
+        full_dataset_id, delete_contents=True, not_found_ok=True
+    )
+
+
+@pytest.fixture()
+def gbq_connector(project, credentials):
+    from pandas_gbq import gbq
+
+    return gbq.GbqConnector(project, credentials=credentials)
+
+
+@pytest.fixture()
+def random_dataset(bigquery_client, random_dataset_id):
+    from google.cloud import bigquery
+
+    dataset_ref = bigquery.DatasetReference(bigquery_client.project, random_dataset_id)
+    dataset = bigquery.Dataset(dataset_ref)
+    bigquery_client.create_dataset(dataset)
+    return dataset
+
+
+@pytest.fixture()
+def tokyo_dataset(bigquery_client, random_dataset_id):
+    from google.cloud import bigquery
+
+    dataset_ref = bigquery.DatasetReference(bigquery_client.project, random_dataset_id)
+    dataset = bigquery.Dataset(dataset_ref)
+    dataset.location = "asia-northeast1"
+    bigquery_client.create_dataset(dataset)
+    return random_dataset_id
+
+
+@pytest.fixture()
+def tokyo_table(bigquery_client, tokyo_dataset):
+    table_id = "tokyo_table"
+    # Create a random table using DDL.
+    # https://github.com/GoogleCloudPlatform/golang-samples/blob/2ab2c6b79a1ea3d71d8f91609b57a8fbde07ae5d/bigquery/snippets/snippet.go#L739
+    bigquery_client.query(
+        """CREATE TABLE {}.{}
+        AS SELECT
+          2000 + CAST(18 * RAND() as INT64) as year,
+          IF(RAND() > 0.5,"foo","bar") as token
+        FROM UNNEST(GENERATE_ARRAY(0,5,1)) as r
+        """.format(
+            tokyo_dataset, table_id
+        ),
+        location="asia-northeast1",
+    ).result()
+    return table_id
+
+
+@pytest.fixture()
+def gbq_dataset(project, credentials):
+    from pandas_gbq import gbq
+
+    return gbq._Dataset(project, credentials=credentials)
+
+
+@pytest.fixture()
+def gbq_table(project, credentials, random_dataset_id):
+    from pandas_gbq import gbq
+
+    return gbq._Table(project, random_dataset_id, credentials=credentials)
diff --git a/packages/pandas-gbq/tests/system/test_auth.py b/packages/pandas-gbq/tests/system/test_auth.py
new file mode 100644
index 000000000000..564625a92d73
--- /dev/null
+++ b/packages/pandas-gbq/tests/system/test_auth.py
@@ -0,0 +1,67 @@
+# Copyright (c) 2017 pandas-gbq Authors All rights reserved.
+# Use of this source code is governed by a BSD-style
+# license that can be found in the LICENSE file.
+
+"""System tests for fetching Google BigQuery credentials."""
+
+import os
+from unittest import mock
+
+import pytest
+
+from pandas_gbq import auth
+
+IS_RUNNING_ON_CI = "KOKORO_BUILD_ID" in os.environ
+
+
+def mock_default_credentials(scopes=None, request=None):
+    return (None, None)
+
+
+def test_should_be_able_to_get_valid_credentials(project_id):
+    credentials, _ = auth.get_credentials(project_id=project_id)
+    assert credentials.valid
+
+
+@pytest.mark.skipif(
+    IS_RUNNING_ON_CI, reason="end-user auth requires human intervention"
+)
+def test_get_credentials_bad_file_returns_user_credentials(project_id, monkeypatch):
+    import google.auth
+    from google.auth.credentials import Credentials
+
+    monkeypatch.setattr(google.auth, "default", mock_default_credentials)
+
+    with mock.patch("__main__.open", side_effect=IOError()):
+        credentials, _ = auth.get_credentials(
+            project_id=project_id, auth_local_webserver=True
+        )
+    assert isinstance(credentials, Credentials)
+
+
+@pytest.mark.skipif(
+    IS_RUNNING_ON_CI, reason="end-user auth requires human intervention"
+)
+def test_get_credentials_user_credentials_with_reauth(project_id, monkeypatch):
+    import google.auth
+
+    monkeypatch.setattr(google.auth, "default", mock_default_credentials)
+
+    credentials, _ = auth.get_credentials(
+        project_id=project_id, reauth=True, auth_local_webserver=True
+    )
+    assert credentials.valid
+
+
+@pytest.mark.skipif(
+    IS_RUNNING_ON_CI, reason="end-user auth requires human intervention"
+)
+def test_get_credentials_user_credentials(project_id, monkeypatch):
+    import google.auth
+
+    monkeypatch.setattr(google.auth, "default", mock_default_credentials)
+
+    credentials, _ = auth.get_credentials(
+        project_id=project_id, auth_local_webserver=True
+    )
+    assert credentials.valid
diff --git a/packages/pandas-gbq/tests/system/test_gbq.py b/packages/pandas-gbq/tests/system/test_gbq.py
new file mode 100644
index 000000000000..1457ec30f0f7
--- /dev/null
+++ b/packages/pandas-gbq/tests/system/test_gbq.py
@@ -0,0 +1,1410 @@
+# Copyright (c) 2017 pandas-gbq Authors All rights reserved.
+# Use of this source code is governed by a BSD-style
+# license that can be found in the LICENSE file.
+
+# -*- coding: utf-8 -*-
+
+import datetime
+import sys
+
+import numpy as np
+import packaging.version
+import pandas
+from pandas import DataFrame
+import pandas.api.types
+import pandas.testing as tm
+import pytest
+import pytz
+
+from pandas_gbq import gbq
+import pandas_gbq.schema
+
+TABLE_ID = "new_test"
+PANDAS_VERSION = packaging.version.parse(pandas.__version__)
+
+
+def test_imports():
+    gbq._test_google_api_imports()
+
+
+def make_mixed_dataframe_v1():
+    # Re-implementation of private pandas.util.testing.makeMixedDataFrame
+    return pandas.DataFrame(
+        {
+            "A": [0.0, 1.0, 2.0, 3.0, 4.0],
+            "B": [0.0, 1.0, 0.0, 1.0, 0.0],
+            "C": ["foo1", "foo2", "foo3", "foo4", "foo5"],
+            "D": pandas.bdate_range("1/1/2009", periods=5),
+        }
+    )
+
+
+def make_mixed_dataframe_v2(test_size):
+    # create df to test for all BQ datatypes except RECORD
+    bools = np.random.randint(2, size=(1, test_size)).astype(bool)
+    flts = np.random.randn(1, test_size)
+    ints = np.random.randint(1, 10, size=(1, test_size))
+    strs = np.random.randint(1, 10, size=(1, test_size)).astype(str)
+    times = [
+        datetime.datetime.now(pytz.timezone("US/Arizona")) for t in range(test_size)
+    ]
+    return DataFrame(
+        {
+            "bools": bools[0],
+            "flts": flts[0],
+            "ints": ints[0],
+            "strs": strs[0],
+            "times": times[0],
+        },
+        index=range(test_size),
+    )
+
+
+def get_schema(gbq_connector: gbq.GbqConnector, dataset_id: str, table_id: str):
+    """Retrieve the schema of the table
+
+    Obtain from BigQuery the field names and field types
+    for the table defined by the parameters
+
+    Parameters
+    ----------
+    dataset_id : str
+        Name of the BigQuery dataset for the table
+    table_id : str
+        Name of the BigQuery table
+
+    Returns
+    -------
+    list of dicts
+        Fields representing the schema
+    """
+    from google.cloud import bigquery
+
+    bqclient = gbq_connector.client
+    table_ref = bigquery.TableReference(
+        bigquery.DatasetReference(bqclient.project, dataset_id),
+        table_id,
+    )
+
+    try:
+        table = bqclient.get_table(table_ref)
+        remote_schema = table.schema
+
+        remote_fields = [field_remote.to_api_repr() for field_remote in remote_schema]
+        for field in remote_fields:
+            field["type"] = field["type"].upper()
+            field["mode"] = field["mode"].upper()
+
+        return remote_fields
+    except gbq_connector.http_error as ex:
+        gbq_connector.process_http_error(ex)
+
+
+def verify_schema(gbq_connector, dataset_id, table_id, schema):
+    """Indicate whether schemas match exactly
+
+    Compare the BigQuery table identified in the parameters with
+    the schema passed in and indicate whether all fields in the former
+    are present in the latter. Order is not considered.
+
+    Parameters
+    ----------
+    dataset_id :str
+        Name of the BigQuery dataset for the table
+    table_id : str
+        Name of the BigQuery table
+    schema : list(dict)
+        Schema for comparison. Each item should have
+        a 'name' and a 'type'
+
+    Returns
+    -------
+    bool
+        Whether the schemas match
+    """
+
+    fields_remote = pandas_gbq.schema._clean_schema_fields(
+        get_schema(gbq_connector, dataset_id, table_id)
+    )
+    fields_local = pandas_gbq.schema._clean_schema_fields(schema["fields"])
+    return fields_remote == fields_local
+
+
+class TestGBQConnectorIntegration(object):
+    def test_should_be_able_to_make_a_connector(self, gbq_connector):
+        assert gbq_connector is not None, "Could not create a GbqConnector"
+
+    def test_should_be_able_to_get_a_bigquery_client(self, gbq_connector):
+        bigquery_client = gbq_connector.get_client()
+        assert bigquery_client is not None
+
+
+class TestReadGBQIntegration(object):
+    @pytest.fixture(autouse=True)
+    def setup(self, project, credentials):
+        # - PER-TEST FIXTURES -
+        # put here any instruction you want to be run *BEFORE* *EVERY* test is
+        # executed.
+        self.gbq_connector = gbq.GbqConnector(project, credentials=credentials)
+        self.credentials = credentials
+
+    def test_unicode_string_conversion_and_normalization(self, project_id):
+        correct_test_datatype = DataFrame({"unicode_string": ["éü"]})
+        unicode_string = "éü"
+        query = 'SELECT "{0}" AS unicode_string'.format(unicode_string)
+
+        df = gbq.read_gbq(
+            query,
+            project_id=project_id,
+            credentials=self.credentials,
+            dialect="legacy",
+        )
+        tm.assert_frame_equal(df, correct_test_datatype)
+
+    def test_index_column(self, project_id):
+        query = "SELECT 'a' AS string_1, 'b' AS string_2"
+        result_frame = gbq.read_gbq(
+            query,
+            project_id=project_id,
+            index_col="string_1",
+            credentials=self.credentials,
+            dialect="legacy",
+        )
+        correct_frame = DataFrame({"string_1": ["a"], "string_2": ["b"]}).set_index(
+            "string_1"
+        )
+        assert result_frame.index.name == correct_frame.index.name
+
+    def test_column_order(self, project_id):
+        query = "SELECT 'a' AS string_1, 'b' AS string_2, 'c' AS string_3"
+        col_order = ["string_3", "string_1", "string_2"]
+        result_frame = gbq.read_gbq(
+            query,
+            project_id=project_id,
+            col_order=col_order,
+            credentials=self.credentials,
+            dialect="legacy",
+        )
+        correct_frame = DataFrame(
+            {"string_1": ["a"], "string_2": ["b"], "string_3": ["c"]}
+        )[col_order]
+        tm.assert_frame_equal(result_frame, correct_frame)
+
+    def test_read_gbq_raises_invalid_column_order(self, project_id):
+        query = "SELECT 'a' AS string_1, 'b' AS string_2, 'c' AS string_3"
+        col_order = ["string_aaa", "string_1", "string_2"]
+
+        # Column string_aaa does not exist. Should raise InvalidColumnOrder
+        with pytest.raises(gbq.InvalidColumnOrder):
+            gbq.read_gbq(
+                query,
+                project_id=project_id,
+                col_order=col_order,
+                credentials=self.credentials,
+                dialect="legacy",
+            )
+
+    def test_column_order_plus_index(self, project_id):
+        query = "SELECT 'a' AS string_1, 'b' AS string_2, 'c' AS string_3"
+        col_order = ["string_3", "string_2"]
+        result_frame = gbq.read_gbq(
+            query,
+            project_id=project_id,
+            index_col="string_1",
+            col_order=col_order,
+            credentials=self.credentials,
+            dialect="legacy",
+        )
+        correct_frame = DataFrame(
+            {"string_1": ["a"], "string_2": ["b"], "string_3": ["c"]}
+        )
+        correct_frame.set_index("string_1", inplace=True)
+        correct_frame = correct_frame[col_order]
+        tm.assert_frame_equal(result_frame, correct_frame)
+
+    def test_read_gbq_raises_invalid_index_column(self, project_id):
+        query = "SELECT 'a' AS string_1, 'b' AS string_2, 'c' AS string_3"
+        col_order = ["string_3", "string_2"]
+
+        # Column string_bbb does not exist. Should raise InvalidIndexColumn
+        with pytest.raises(gbq.InvalidIndexColumn):
+            gbq.read_gbq(
+                query,
+                project_id=project_id,
+                index_col="string_bbb",
+                col_order=col_order,
+                credentials=self.credentials,
+                dialect="legacy",
+            )
+
+    def test_malformed_query(self, project_id):
+        with pytest.raises(gbq.GenericGBQException):
+            gbq.read_gbq(
+                "SELCET * FORM [publicdata:samples.shakespeare]",
+                project_id=project_id,
+                credentials=self.credentials,
+                dialect="legacy",
+            )
+
+    def test_bad_project_id(self):
+        with pytest.raises(gbq.GenericGBQException):
+            gbq.read_gbq(
+                "SELCET * FROM [publicdata:samples.shakespeare]",
+                project_id="not-my-project",
+                credentials=self.credentials,
+                dialect="legacy",
+            )
+
+    def test_bad_table_name(self, project_id):
+        with pytest.raises(gbq.GenericGBQException):
+            gbq.read_gbq(
+                "SELECT * FROM [publicdata:samples.nope]",
+                project_id=project_id,
+                credentials=self.credentials,
+                dialect="legacy",
+            )
+
+    def test_download_dataset_larger_than_200k_rows(self, project_id):
+        test_size = 200005
+        # Test for known BigQuery bug in datasets larger than 100k rows
+        # http://stackoverflow.com/questions/19145587/bq-py-not-paging-results
+        df = gbq.read_gbq(
+            "SELECT id FROM [publicdata:samples.wikipedia] "
+            "GROUP EACH BY id ORDER BY id ASC LIMIT {0}".format(test_size),
+            project_id=project_id,
+            credentials=self.credentials,
+            dialect="legacy",
+        )
+        assert len(df.drop_duplicates()) == test_size
+
+    def test_ddl(self, random_dataset, project_id):
+        # Bug fix for https://github.com/pydata/pandas-gbq/issues/45
+        df = gbq.read_gbq(
+            "CREATE OR REPLACE TABLE {}.test_ddl (x INT64)".format(
+                random_dataset.dataset_id
+            )
+        )
+        assert len(df) == 0
+
+    def test_ddl_w_max_results(self, random_dataset, project_id):
+        df = gbq.read_gbq(
+            "CREATE OR REPLACE TABLE {}.test_ddl (x INT64)".format(
+                random_dataset.dataset_id
+            ),
+            max_results=0,
+        )
+        assert df is None
+
+    def test_max_results(self, random_dataset, project_id):
+        df = gbq.read_gbq(
+            "SELECT * FROM UNNEST(GENERATE_ARRAY(1, 100))", max_results=10
+        )
+        assert len(df) == 10
+
+    def test_one_row_one_column(self, project_id):
+        df = gbq.read_gbq(
+            "SELECT 3 as v",
+            project_id=project_id,
+            credentials=self.credentials,
+            dialect="standard",
+        )
+        expected_result = DataFrame(dict(v=[3]), dtype="Int64")
+        tm.assert_frame_equal(df, expected_result)
+
+    def test_legacy_sql(self, project_id):
+        legacy_sql = "SELECT id FROM [publicdata.samples.wikipedia] LIMIT 10"
+
+        # Test that a legacy sql statement fails when
+        # setting dialect='standard'
+        with pytest.raises(gbq.GenericGBQException):
+            gbq.read_gbq(
+                legacy_sql,
+                project_id=project_id,
+                dialect="standard",
+                credentials=self.credentials,
+            )
+
+        # Test that a legacy sql statement succeeds when
+        # setting dialect='legacy'
+        df = gbq.read_gbq(
+            legacy_sql,
+            project_id=project_id,
+            dialect="legacy",
+            credentials=self.credentials,
+        )
+        assert len(df.drop_duplicates()) == 10
+
+    def test_standard_sql(self, project_id):
+        standard_sql = (
+            "SELECT DISTINCT id FROM " "`publicdata.samples.wikipedia` LIMIT 10"
+        )
+
+        # Test that a standard sql statement fails when using
+        # the legacy SQL dialect.
+        with pytest.raises(gbq.GenericGBQException):
+            gbq.read_gbq(
+                standard_sql,
+                project_id=project_id,
+                credentials=self.credentials,
+                dialect="legacy",
+            )
+
+        # Test that a standard sql statement succeeds when
+        # setting dialect='standard'
+        df = gbq.read_gbq(
+            standard_sql,
+            project_id=project_id,
+            dialect="standard",
+            credentials=self.credentials,
+        )
+        assert len(df.drop_duplicates()) == 10
+
+    def test_query_with_parameters(self, project_id):
+        sql_statement = "SELECT @param1 + @param2 AS valid_result"
+        config = {
+            "query": {
+                "useLegacySql": False,
+                "parameterMode": "named",
+                "queryParameters": [
+                    {
+                        "name": "param1",
+                        "parameterType": {"type": "INTEGER"},
+                        "parameterValue": {"value": 1},
+                    },
+                    {
+                        "name": "param2",
+                        "parameterType": {"type": "INTEGER"},
+                        "parameterValue": {"value": 2},
+                    },
+                ],
+            }
+        }
+        # Test that a query that relies on parameters fails
+        # when parameters are not supplied via configuration
+        with pytest.raises(ValueError):
+            gbq.read_gbq(
+                sql_statement,
+                project_id=project_id,
+                credentials=self.credentials,
+                dialect="legacy",
+            )
+
+        # Test that the query is successful because we have supplied
+        # the correct query parameters via the 'config' option
+        df = gbq.read_gbq(
+            sql_statement,
+            project_id=project_id,
+            credentials=self.credentials,
+            configuration=config,
+            dialect="legacy",
+        )
+        tm.assert_frame_equal(df, DataFrame({"valid_result": [3]}, dtype="Int64"))
+
+    def test_query_inside_configuration(self, project_id):
+        query_no_use = 'SELECT "PI_WRONG" AS valid_string'
+        query = 'SELECT "PI" AS valid_string'
+        config = {"query": {"query": query, "useQueryCache": False}}
+        # Test that it can't pass query both
+        # inside config and as parameter
+        with pytest.raises(ValueError):
+            gbq.read_gbq(
+                query_no_use,
+                project_id=project_id,
+                credentials=self.credentials,
+                configuration=config,
+                dialect="legacy",
+            )
+
+        df = gbq.read_gbq(
+            None,
+            project_id=project_id,
+            credentials=self.credentials,
+            configuration=config,
+            dialect="legacy",
+        )
+        tm.assert_frame_equal(df, DataFrame({"valid_string": ["PI"]}))
+
+    def test_configuration_without_query(self, project_id):
+        sql_statement = "SELECT 1"
+        config = {
+            "copy": {
+                "sourceTable": {
+                    "projectId": project_id,
+                    "datasetId": "publicdata:samples",
+                    "tableId": "wikipedia",
+                },
+                "destinationTable": {
+                    "projectId": project_id,
+                    "datasetId": "publicdata:samples",
+                    "tableId": "wikipedia_copied",
+                },
+            }
+        }
+        # Test that only 'query' configurations are supported
+        # nor 'copy','load','extract'
+        with pytest.raises(ValueError):
+            gbq.read_gbq(
+                sql_statement,
+                project_id=project_id,
+                credentials=self.credentials,
+                configuration=config,
+                dialect="legacy",
+            )
+
+    def test_configuration_raises_value_error_with_multiple_config(self, project_id):
+        sql_statement = "SELECT 1"
+        config = {
+            "query": {"query": sql_statement, "useQueryCache": False},
+            "load": {"query": sql_statement, "useQueryCache": False},
+        }
+        # Test that only ValueError is raised with multiple configurations
+        with pytest.raises(ValueError):
+            gbq.read_gbq(
+                sql_statement,
+                project_id=project_id,
+                credentials=self.credentials,
+                configuration=config,
+                dialect="legacy",
+            )
+
+    def test_timeout_configuration(self, project_id):
+        sql_statement = """
+        select count(*) from unnest(generate_array(1,1000000)), unnest(generate_array(1, 10000))
+        """
+
+        # This first test confirms that we get a timeout error if we exceed the timeout limit.
+        # The above query is expected to take a long time and exceed the limit.
+        configs = [
+            # we have a minimum limit on the timeout_ms being 400 milliseconds
+            # see pandas-gbq/gbq.py/GbqConnector/run_query docstring
+            # for more details.
+            # pandas-gbq timeout configuration. Transformed to REST API compatible version.
+            {"query": {"useQueryCache": False, "timeoutMs": 401}},
+            # REST API job timeout. See:
+            # https://cloud.google.com/bigquery/docs/reference/rest/v2/Job#JobConfiguration.FIELDS.job_timeout_ms
+            {"query": {"useQueryCache": False}, "jobTimeoutMs": 401},
+        ]
+        for config in configs:
+            with pytest.raises(gbq.QueryTimeout):
+                gbq.read_gbq(
+                    sql_statement,
+                    project_id=project_id,
+                    credentials=self.credentials,
+                    configuration=config,
+                )
+
+        # This second test confirms out our validation logic won't allow a
+        # value less than or equal to 400 be used as a timeout value.
+        # by exercising the system for various edge cases to ensure we catch
+        # invalid values less than or equal to 400.
+        configs = [
+            {"query": {"useQueryCache": False, "timeoutMs": 399}},
+            {"query": {"useQueryCache": False, "timeoutMs": 400}},
+            {"query": {"useQueryCache": False, "timeoutMs": 1}},
+            {"query": {"useQueryCache": False}, "jobTimeoutMs": 399},
+            {"query": {"useQueryCache": False}, "jobTimeoutMs": 400},
+            {"query": {"useQueryCache": False}, "jobTimeoutMs": 1},
+        ]
+
+        for config in configs:
+            with pytest.raises(gbq.QueryTimeout):
+                gbq.read_gbq(
+                    sql_statement,
+                    project_id=project_id,
+                    credentials=self.credentials,
+                    configuration=config,
+                )
+
+    def test_struct(self, project_id):
+        query = """SELECT 1 int_field,
+                   STRUCT("a" as letter, 1 as num) struct_field"""
+        df = gbq.read_gbq(
+            query,
+            project_id=project_id,
+            credentials=self.credentials,
+            dialect="standard",
+        )
+        expected = DataFrame(
+            {
+                "int_field": pandas.Series([1], dtype="Int64"),
+                "struct_field": [{"letter": "a", "num": 1}],
+            },
+            columns=["int_field", "struct_field"],
+        )
+        tm.assert_frame_equal(df, expected)
+
+    def test_array(self, project_id):
+        query = """select ["a","x","b","y","c","z"] as letters"""
+        df = gbq.read_gbq(
+            query,
+            project_id=project_id,
+            credentials=self.credentials,
+            dialect="standard",
+        )
+        tm.assert_frame_equal(
+            df,
+            DataFrame([[["a", "x", "b", "y", "c", "z"]]], columns=["letters"]),
+        )
+
+    def test_array_length_zero(self, project_id):
+        query = """WITH t as (
+                   SELECT "a" letter, [""] as array_field
+                   UNION ALL
+                   SELECT "b" letter, [] as array_field)
+
+                   select letter, array_field, array_length(array_field) len
+                   from t
+                   order by letter ASC"""
+        df = gbq.read_gbq(
+            query,
+            project_id=project_id,
+            credentials=self.credentials,
+            dialect="standard",
+        )
+        expected = DataFrame(
+            {
+                "letter": ["a", "b"],
+                "array_field": [[""], []],
+                "len": pandas.Series([1, 0], dtype="Int64"),
+            },
+            columns=["letter", "array_field", "len"],
+        )
+        tm.assert_frame_equal(df, expected)
+
+    def test_array_agg(self, project_id):
+        query = """WITH t as (
+                SELECT "a" letter, 1 num
+                UNION ALL
+                SELECT "b" letter, 2 num
+                UNION ALL
+                SELECT "a" letter, 3 num)
+
+                select letter, array_agg(num order by num ASC) numbers
+                from t
+                group by letter
+                order by letter ASC"""
+        df = gbq.read_gbq(
+            query,
+            project_id=project_id,
+            credentials=self.credentials,
+            dialect="standard",
+        )
+        tm.assert_frame_equal(
+            df,
+            DataFrame([["a", [1, 3]], ["b", [2]]], columns=["letter", "numbers"]),
+        )
+
+    def test_array_of_floats(self, project_id):
+        query = """select [1.1, 2.2, 3.3] as a, 4 as b"""
+        df = gbq.read_gbq(
+            query,
+            project_id=project_id,
+            credentials=self.credentials,
+            dialect="standard",
+        )
+        tm.assert_frame_equal(
+            df,
+            DataFrame(
+                {"a": [[1.1, 2.2, 3.3]], "b": pandas.Series([4], dtype="Int64")},
+                columns=["a", "b"],
+            ),
+        )
+
+    def test_tokyo(self, tokyo_dataset, tokyo_table, project_id):
+        df = gbq.read_gbq(
+            "SELECT MAX(year) AS max_year FROM {}.{}".format(
+                tokyo_dataset, tokyo_table
+            ),
+            dialect="standard",
+            location="asia-northeast1",
+            project_id=project_id,
+            credentials=self.credentials,
+        )
+        assert df["max_year"][0] >= 2000
+
+    def test_columns_as_alias(self, project_id):
+        query = "SELECT 'a' AS string_1, 'b' AS string_2, 'c' AS string_3"
+        columns = ["string_2", "string_1", "string_3"]
+
+        df = gbq.read_gbq(
+            query,
+            project_id=project_id,
+            columns=columns,
+            credentials=self.credentials,
+            dialect="standard",
+        )
+
+        expected = DataFrame({"string_1": ["a"], "string_2": ["b"], "string_3": ["c"]})[
+            columns
+        ]
+
+        # Verify that the result_frame matches the expected DataFrame
+        tm.assert_frame_equal(df, expected)
+
+    def test_columns_and_col_order_raises_error(self, project_id):
+        query = "SELECT 'a' AS string_1, 'b' AS string_2, 'c' AS string_3"
+        columns = ["string_2", "string_1"]
+        col_order = ["string_3", "string_1", "string_2"]
+
+        with pytest.raises(ValueError):
+            gbq.read_gbq(
+                query,
+                project_id=project_id,
+                columns=columns,
+                col_order=col_order,
+                credentials=self.credentials,
+                dialect="standard",
+            )
+
+
+class TestToGBQIntegration(object):
+    @pytest.fixture(autouse=True, scope="function")
+    def setup(self, project, credentials, random_dataset_id):
+        # - PER-TEST FIXTURES -
+        # put here any instruction you want to be run *BEFORE* *EVERY* test is
+        # executed.
+        self.credentials = credentials
+        self.gbq_connector = gbq.GbqConnector(project, credentials=credentials)
+        self.bqclient = self.gbq_connector.client
+        self.table = gbq._Table(project, random_dataset_id, credentials=credentials)
+        self.destination_table = "{}.{}".format(random_dataset_id, TABLE_ID)
+
+    def test_upload_data(self, project_id):
+        test_id = "1"
+        test_size = 20001
+        df = make_mixed_dataframe_v2(test_size)
+
+        gbq.to_gbq(
+            df,
+            self.destination_table + test_id,
+            project_id,
+            chunksize=10000,
+            credentials=self.credentials,
+        )
+
+        result = gbq.read_gbq(
+            "SELECT COUNT(*) AS num_rows FROM {0}".format(
+                self.destination_table + test_id
+            ),
+            project_id=project_id,
+            credentials=self.credentials,
+            dialect="legacy",
+        )
+        assert result["num_rows"][0] == test_size
+
+    def test_upload_empty_data(self, project_id):
+        test_id = "data_with_0_rows"
+        df = DataFrame()
+
+        gbq.to_gbq(
+            df,
+            self.destination_table + test_id,
+            project_id,
+            credentials=self.credentials,
+        )
+
+        table = self.bqclient.get_table(self.destination_table + test_id)
+        assert table.num_rows == 0
+        assert len(table.schema) == 0
+
+    def test_upload_empty_data_with_schema(self, project_id):
+        test_id = "data_with_0_rows"
+        df = DataFrame(
+            {"a": pandas.Series(dtype="int64"), "b": pandas.Series(dtype="object")}
+        )
+
+        gbq.to_gbq(
+            df,
+            self.destination_table + test_id,
+            project_id,
+            credentials=self.credentials,
+        )
+
+        table = self.bqclient.get_table(self.destination_table + test_id)
+        assert table.num_rows == 0
+        schema = table.schema
+        assert schema[0].field_type == "INTEGER"
+        assert schema[1].field_type == "STRING"
+
+    def test_upload_data_if_table_exists_fail(self, project_id):
+        test_id = "2"
+        test_size = 10
+        df = make_mixed_dataframe_v2(test_size)
+
+        # Initialize table with sample data
+        gbq.to_gbq(
+            df,
+            self.destination_table + test_id,
+            project_id,
+            chunksize=10000,
+            credentials=self.credentials,
+        )
+
+        # Test the default value of if_exists == 'fail'
+        with pytest.raises(gbq.TableCreationError):
+            gbq.to_gbq(
+                df,
+                self.destination_table + test_id,
+                project_id,
+                credentials=self.credentials,
+            )
+
+        # Test the if_exists parameter with value 'fail'
+        with pytest.raises(gbq.TableCreationError):
+            gbq.to_gbq(
+                df,
+                self.destination_table + test_id,
+                project_id,
+                if_exists="fail",
+                credentials=self.credentials,
+            )
+
+    def test_upload_data_if_table_exists_append(self, project_id):
+        test_id = "3"
+        test_size = 10
+        df = make_mixed_dataframe_v2(test_size)
+        df_different_schema = make_mixed_dataframe_v1()
+
+        # Initialize table with sample data
+        gbq.to_gbq(
+            df,
+            self.destination_table + test_id,
+            project_id,
+            chunksize=10000,
+            credentials=self.credentials,
+        )
+
+        # Test the if_exists parameter with value 'append'
+        gbq.to_gbq(
+            df,
+            self.destination_table + test_id,
+            project_id,
+            if_exists="append",
+            credentials=self.credentials,
+        )
+
+        result = gbq.read_gbq(
+            "SELECT COUNT(*) AS num_rows FROM {0}".format(
+                self.destination_table + test_id
+            ),
+            project_id=project_id,
+            credentials=self.credentials,
+            dialect="legacy",
+        )
+        assert result["num_rows"][0] == test_size * 2
+
+        # Try inserting with a different schema, confirm failure
+        with pytest.raises(gbq.InvalidSchema):
+            gbq.to_gbq(
+                df_different_schema,
+                self.destination_table + test_id,
+                project_id,
+                if_exists="append",
+                credentials=self.credentials,
+            )
+
+    def test_upload_subset_columns_if_table_exists_append(self, project_id):
+        # Issue 24: Upload is succesful if dataframe has columns
+        # which are a subset of the current schema
+        test_id = "16"
+        test_size = 10
+        df = make_mixed_dataframe_v2(test_size)
+        df_subset_cols = df.iloc[:, :2]
+
+        # Initialize table with sample data
+        gbq.to_gbq(
+            df,
+            self.destination_table + test_id,
+            project_id,
+            chunksize=10000,
+            credentials=self.credentials,
+        )
+
+        # Test the if_exists parameter with value 'append'
+        gbq.to_gbq(
+            df_subset_cols,
+            self.destination_table + test_id,
+            project_id,
+            if_exists="append",
+            credentials=self.credentials,
+        )
+
+        result = gbq.read_gbq(
+            "SELECT COUNT(*) AS num_rows FROM {0}".format(
+                self.destination_table + test_id
+            ),
+            project_id=project_id,
+            credentials=self.credentials,
+            dialect="legacy",
+        )
+        assert result["num_rows"][0] == test_size * 2
+
+    def test_upload_data_if_table_exists_replace(self, project_id):
+        test_id = "4"
+        test_size = 10
+        df = make_mixed_dataframe_v2(test_size)
+        df_different_schema = make_mixed_dataframe_v1()
+        schema_new = gbq.generate_bq_schema(df_different_schema)
+
+        # Initialize table with sample data
+        gbq.to_gbq(
+            df,
+            self.destination_table + test_id,
+            project_id,
+            chunksize=10000,
+            credentials=self.credentials,
+        )
+
+        # When if_exists == 'replace', table schema should change too.
+        gbq.to_gbq(
+            df_different_schema,
+            self.destination_table + test_id,
+            project_id,
+            if_exists="replace",
+            credentials=self.credentials,
+        )
+
+        df_new = gbq.read_gbq(
+            "SELECT * FROM {0}".format(self.destination_table + test_id),
+            project_id=project_id,
+            credentials=self.credentials,
+            dialect="legacy",
+        )
+
+        schema_returned = gbq.generate_bq_schema(df_new)
+        assert schema_new == schema_returned
+        assert df_new.shape[0] == 5
+
+    def test_upload_data_if_table_exists_raises_value_error(self, project_id):
+        test_id = "4"
+        test_size = 10
+        df = make_mixed_dataframe_v2(test_size)
+
+        # Test invalid value for if_exists parameter raises value error
+        with pytest.raises(ValueError):
+            gbq.to_gbq(
+                df,
+                self.destination_table + test_id,
+                project_id,
+                if_exists="xxxxx",
+                credentials=self.credentials,
+            )
+
+    def test_google_upload_errors_should_raise_exception(self, project_id):
+        raise pytest.skip("buggy test")
+
+        test_id = "5"
+        test_timestamp = datetime.datetime.now(pytz.timezone("US/Arizona"))
+        bad_df = DataFrame(
+            {
+                "bools": [False, False],
+                "flts": [0.0, 1.0],
+                "ints": [0, "1"],
+                "strs": ["a", 1],
+                "times": [test_timestamp, test_timestamp],
+            },
+            index=range(2),
+        )
+
+        with pytest.raises(gbq.StreamingInsertError):
+            gbq.to_gbq(
+                bad_df,
+                self.destination_table + test_id,
+                project_id,
+                credentials=self.credentials,
+            )
+
+    def test_upload_mixed_float_and_int(self, project_id):
+        """Test that we can upload a dataframe containing an int64 and float64 column.
+        See: https://github.com/pydata/pandas-gbq/issues/116
+        """
+        test_id = "mixed_float_and_int"
+        test_size = 2
+        df = DataFrame(
+            [[1, 1.1], [2, 2.2]],
+            index=["row 1", "row 2"],
+            columns=["intColumn", "floatColumn"],
+        )
+
+        gbq.to_gbq(
+            df,
+            self.destination_table + test_id,
+            project_id=project_id,
+            credentials=self.credentials,
+        )
+
+        result_df = gbq.read_gbq(
+            "SELECT * FROM {0}".format(self.destination_table + test_id),
+            project_id=project_id,
+            credentials=self.credentials,
+            dialect="legacy",
+        )
+
+        assert len(result_df) == test_size
+
+    def test_upload_data_with_newlines(self, project_id):
+        test_id = "data_with_newlines"
+        test_size = 2
+        df = DataFrame({"s": ["abcd", "ef\ngh"]})
+
+        gbq.to_gbq(
+            df,
+            self.destination_table + test_id,
+            project_id=project_id,
+            credentials=self.credentials,
+        )
+
+        result_df = gbq.read_gbq(
+            "SELECT * FROM {0}".format(self.destination_table + test_id),
+            project_id=project_id,
+            credentials=self.credentials,
+            dialect="legacy",
+        )
+
+        assert len(result_df) == test_size
+
+        if sys.version_info.major < 3:
+            pytest.skip(msg="Unicode comparison in Py2 not working")
+
+        result = result_df["s"].sort_values()
+        expected = df["s"].sort_values()
+
+        tm.assert_series_equal(expected, result)
+
+    def test_upload_data_flexible_column_order(self, project_id):
+        test_id = "13"
+        test_size = 10
+        df = make_mixed_dataframe_v2(test_size)
+
+        # Initialize table with sample data
+        gbq.to_gbq(
+            df,
+            self.destination_table + test_id,
+            project_id,
+            chunksize=10000,
+            credentials=self.credentials,
+        )
+
+        df_columns_reversed = df[df.columns[::-1]]
+
+        gbq.to_gbq(
+            df_columns_reversed,
+            self.destination_table + test_id,
+            project_id,
+            if_exists="append",
+            credentials=self.credentials,
+        )
+
+    def test_upload_data_with_valid_user_schema(self, project_id):
+        # Issue #46; tests test scenarios with user-provided
+        # schemas
+        df = make_mixed_dataframe_v1()
+        test_id = "18"
+        test_schema = [
+            {"name": "A", "type": "FLOAT"},
+            {"name": "B", "type": "FLOAT"},
+            {"name": "C", "type": "STRING"},
+            {"name": "D", "type": "TIMESTAMP"},
+        ]
+        destination_table = self.destination_table + test_id
+        gbq.to_gbq(
+            df,
+            destination_table,
+            project_id,
+            credentials=self.credentials,
+            table_schema=test_schema,
+        )
+        dataset, table = destination_table.split(".")
+        assert verify_schema(
+            self.gbq_connector, dataset, table, dict(fields=test_schema)
+        )
+
+    def test_upload_data_with_invalid_user_schema_raises_error(self, project_id):
+        df = make_mixed_dataframe_v1()
+        test_id = "19"
+        test_schema = [
+            {"name": "A", "type": "FLOAT"},
+            {"name": "B", "type": "FLOAT"},
+            {"name": "C", "type": "FLOAT"},
+            {"name": "D", "type": "FLOAT"},
+        ]
+        destination_table = self.destination_table + test_id
+        with pytest.raises(gbq.GenericGBQException):
+            gbq.to_gbq(
+                df,
+                destination_table,
+                project_id,
+                credentials=self.credentials,
+                table_schema=test_schema,
+            )
+
+    def test_upload_data_with_missing_schema_fields_raises_error(self, project_id):
+        df = make_mixed_dataframe_v1()
+        test_id = "20"
+        test_schema = [
+            {"name": "A", "type": "FLOAT"},
+            {"name": "B", "type": "FLOAT"},
+            {"name": "C", "type": "FLOAT"},
+        ]
+        destination_table = self.destination_table + test_id
+        with pytest.raises(gbq.GenericGBQException):
+            gbq.to_gbq(
+                df,
+                destination_table,
+                project_id,
+                credentials=self.credentials,
+                table_schema=test_schema,
+            )
+
+    @pytest.mark.skipif(
+        packaging.version.parse(pandas.__version__).release >= (2, 0), reason=""
+    )
+    def test_upload_data_with_timestamp(self, project_id):
+        test_id = "21"
+        test_size = 6
+        df = DataFrame(
+            np.random.randn(test_size, 4),
+            index=range(test_size),
+            columns=list("ABCD"),
+        )
+        df["times"] = pandas.Series(
+            [
+                "2018-03-13T05:40:45.348318",
+                "2018-04-13T05:40:45.348318",
+                "2018-05-13T05:40:45.348318",
+                "2018-06-13T05:40:45.348318",
+                "2018-07-13T05:40:45.348318",
+                "2018-08-13T05:40:45.348318",
+            ],
+            dtype="datetime64[ns]",
+        ).dt.tz_localize("UTC")
+
+        gbq.to_gbq(
+            df,
+            self.destination_table + test_id,
+            project_id=project_id,
+            credentials=self.credentials,
+        )
+
+        result_df = gbq.read_gbq(
+            "SELECT * FROM {0}".format(self.destination_table + test_id),
+            project_id=project_id,
+            credentials=self.credentials,
+            dialect="legacy",
+        )
+
+        assert len(result_df) == test_size
+
+        expected = df["times"].sort_values()
+        result = result_df["times"].sort_values()
+        tm.assert_series_equal(expected, result)
+
+    def test_upload_data_with_different_df_and_user_schema(self, project_id):
+        df = make_mixed_dataframe_v1()
+        df["A"] = df["A"].astype(str)
+        df["B"] = df["B"].astype(str)
+        test_id = "22"
+        test_schema = [
+            {"name": "A", "type": "FLOAT"},
+            {"name": "B", "type": "FLOAT"},
+            {"name": "C", "type": "STRING"},
+            {"name": "D", "type": "TIMESTAMP"},
+        ]
+        destination_table = self.destination_table + test_id
+        gbq.to_gbq(
+            df,
+            destination_table,
+            project_id,
+            credentials=self.credentials,
+            table_schema=test_schema,
+            # Loading string pandas series to FLOAT column not supported with
+            # Parquet.
+            api_method="load_csv",
+        )
+        dataset, table = destination_table.split(".")
+        assert verify_schema(
+            self.gbq_connector, dataset, table, dict(fields=test_schema)
+        )
+
+    def test_upload_data_tokyo(self, project_id, tokyo_dataset, bigquery_client):
+        from google.cloud import bigquery
+
+        test_size = 10
+        df = make_mixed_dataframe_v2(test_size)
+        tokyo_destination = "{}.to_gbq_test".format(tokyo_dataset)
+
+        # Initialize table with sample data
+        gbq.to_gbq(
+            df,
+            tokyo_destination,
+            project_id,
+            credentials=self.credentials,
+            location="asia-northeast1",
+        )
+
+        table = bigquery_client.get_table(
+            bigquery.TableReference(
+                bigquery.DatasetReference(project_id, tokyo_dataset),
+                "to_gbq_test",
+            )
+        )
+        assert table.num_rows > 0
+
+    def test_upload_data_tokyo_non_existing_dataset(
+        self, project_id, random_dataset_id, bigquery_client
+    ):
+        from google.cloud import bigquery
+
+        test_size = 10
+        df = make_mixed_dataframe_v2(test_size)
+        non_existing_tokyo_dataset = random_dataset_id
+        non_existing_tokyo_destination = "{}.to_gbq_test".format(
+            non_existing_tokyo_dataset
+        )
+
+        # Initialize table with sample data
+        gbq.to_gbq(
+            df,
+            non_existing_tokyo_destination,
+            project_id,
+            credentials=self.credentials,
+            location="asia-northeast1",
+        )
+
+        table = bigquery_client.get_table(
+            bigquery.TableReference(
+                bigquery.DatasetReference(project_id, non_existing_tokyo_dataset),
+                "to_gbq_test",
+            )
+        )
+        assert table.num_rows > 0
+
+
+# _Dataset tests
+
+
+def test_create_dataset(bigquery_client, gbq_dataset, random_dataset_id, project_id):
+    from google.cloud import bigquery
+
+    gbq_dataset.create(random_dataset_id)
+    dataset_reference = bigquery.DatasetReference(project_id, random_dataset_id)
+    assert bigquery_client.get_dataset(dataset_reference) is not None
+
+
+def test_create_dataset_already_exists(gbq_dataset, random_dataset_id):
+    gbq_dataset.create(random_dataset_id)
+    with pytest.raises(gbq.DatasetCreationError):
+        gbq_dataset.create(random_dataset_id)
+
+
+def test_dataset_exists(gbq_dataset, random_dataset_id):
+    gbq_dataset.create(random_dataset_id)
+    assert gbq_dataset.exists(random_dataset_id)
+
+
+def test_dataset_does_not_exist(gbq_dataset, random_dataset_id):
+    assert not gbq_dataset.exists(random_dataset_id)
+
+
+# _Table tests
+
+
+def test_create_table(gbq_table):
+    schema = gbq._generate_bq_schema(make_mixed_dataframe_v1())
+    gbq_table.create("test_create_table", schema)
+    assert gbq_table.exists("test_create_table")
+
+
+def test_create_table_already_exists(gbq_table):
+    schema = gbq._generate_bq_schema(make_mixed_dataframe_v1())
+    gbq_table.create("test_create_table_exists", schema)
+    with pytest.raises(gbq.TableCreationError):
+        gbq_table.create("test_create_table_exists", schema)
+
+
+def test_table_does_not_exist(gbq_table):
+    assert not gbq_table.exists("test_table_does_not_exist")
+
+
+def test_delete_table(gbq_table):
+    test_schema = {
+        "fields": [
+            {"name": "A", "type": "FLOAT"},
+            {"name": "B", "type": "FLOAT"},
+            {"name": "C", "type": "STRING"},
+            {"name": "D", "type": "TIMESTAMP"},
+        ]
+    }
+    gbq_table.create("test_delete_table", test_schema)
+    gbq_table.delete("test_delete_table")
+    assert not gbq_table.exists("test_delete_table")
+
+
+def test_create_table_data_dataset_does_not_exist(
+    project, credentials, gbq_dataset, random_dataset_id
+):
+    table_id = "test_create_table_data_dataset_does_not_exist"
+    table_with_new_dataset = gbq._Table(
+        project, random_dataset_id, credentials=credentials
+    )
+    df = make_mixed_dataframe_v2(10)
+    table_with_new_dataset.create(table_id, gbq._generate_bq_schema(df))
+    assert gbq_dataset.exists(random_dataset_id)
+    assert table_with_new_dataset.exists(table_id)
+
+
+def test_verify_schema_allows_flexible_column_order(gbq_table, gbq_connector):
+    table_id = "test_verify_schema_allows_flexible_column_order"
+    test_schema_1 = {
+        "fields": [
+            {"name": "A", "type": "FLOAT"},
+            {"name": "B", "type": "FLOAT"},
+            {"name": "C", "type": "STRING"},
+            {"name": "D", "type": "TIMESTAMP"},
+        ]
+    }
+    test_schema_2 = {
+        "fields": [
+            {"name": "A", "type": "FLOAT"},
+            {"name": "C", "type": "STRING"},
+            {"name": "B", "type": "FLOAT"},
+            {"name": "D", "type": "TIMESTAMP"},
+        ]
+    }
+
+    gbq_table.create(table_id, test_schema_1)
+    assert verify_schema(gbq_connector, gbq_table.dataset_id, table_id, test_schema_2)
+
+
+def test_verify_schema_fails_different_data_type(gbq_table, gbq_connector):
+    table_id = "test_verify_schema_fails_different_data_type"
+    test_schema_1 = {
+        "fields": [
+            {"name": "A", "type": "FLOAT"},
+            {"name": "B", "type": "FLOAT"},
+            {"name": "C", "type": "STRING"},
+            {"name": "D", "type": "TIMESTAMP"},
+        ]
+    }
+    test_schema_2 = {
+        "fields": [
+            {"name": "A", "type": "FLOAT"},
+            {"name": "B", "type": "STRING"},
+            {"name": "C", "type": "STRING"},
+            {"name": "D", "type": "TIMESTAMP"},
+        ]
+    }
+
+    gbq_table.create(table_id, test_schema_1)
+    assert not verify_schema(
+        gbq_connector, gbq_table.dataset_id, table_id, test_schema_2
+    )
+
+
+def test_verify_schema_fails_different_structure(gbq_table, gbq_connector):
+    table_id = "test_verify_schema_fails_different_structure"
+    test_schema_1 = {
+        "fields": [
+            {"name": "A", "type": "FLOAT"},
+            {"name": "B", "type": "FLOAT"},
+            {"name": "C", "type": "STRING"},
+            {"name": "D", "type": "TIMESTAMP"},
+        ]
+    }
+    test_schema_2 = {
+        "fields": [
+            {"name": "A", "type": "FLOAT"},
+            {"name": "B2", "type": "FLOAT"},
+            {"name": "C", "type": "STRING"},
+            {"name": "D", "type": "TIMESTAMP"},
+        ]
+    }
+
+    gbq_table.create(table_id, test_schema_1)
+    assert not verify_schema(
+        gbq_connector, gbq_table.dataset_id, table_id, test_schema_2
+    )
+
+
+def test_verify_schema_ignores_field_mode(gbq_table, gbq_connector):
+    table_id = "test_verify_schema_ignores_field_mode"
+    test_schema_1 = {
+        "fields": [
+            {"name": "A", "type": "FLOAT", "mode": "NULLABLE"},
+            {"name": "B", "type": "FLOAT", "mode": "NULLABLE"},
+            {"name": "C", "type": "STRING", "mode": "NULLABLE"},
+            {"name": "D", "type": "TIMESTAMP", "mode": "REQUIRED"},
+        ]
+    }
+    test_schema_2 = {
+        "fields": [
+            {"name": "A", "type": "FLOAT"},
+            {"name": "B", "type": "FLOAT"},
+            {"name": "C", "type": "STRING"},
+            {"name": "D", "type": "TIMESTAMP"},
+        ]
+    }
+
+    gbq_table.create(table_id, test_schema_1)
+    assert verify_schema(gbq_connector, gbq_table.dataset_id, table_id, test_schema_2)
+
+
+def test_retrieve_schema(gbq_table, gbq_connector):
+    # Issue #24 schema function returns the schema in biquery
+    table_id = "test_retrieve_schema"
+    test_schema = {
+        "fields": [
+            {"name": "A", "type": "FLOAT", "mode": "NULLABLE", "description": None},
+            {"name": "B", "type": "FLOAT", "mode": "NULLABLE", "description": None},
+            {"name": "C", "type": "STRING", "mode": "NULLABLE", "description": None},
+            {
+                "name": "D",
+                "type": "TIMESTAMP",
+                "mode": "NULLABLE",
+                "description": None,
+            },
+        ]
+    }
+
+    gbq_table.create(table_id, test_schema)
+    expected = [
+        {"name": "A", "type": "FLOAT"},
+        {"name": "B", "type": "FLOAT"},
+        {"name": "C", "type": "STRING"},
+        {"name": "D", "type": "TIMESTAMP"},
+    ]
+    assert verify_schema(
+        gbq_connector, gbq_table.dataset_id, table_id, {"fields": expected}
+    )
+
+
+def test_to_gbq_does_not_override_mode(gbq_table, gbq_connector):
+    # See: https://github.com/pydata/pandas-gbq/issues/315
+    table_id = "test_to_gbq_does_not_override_mode"
+    table_schema = {
+        "fields": [
+            {"mode": "REQUIRED", "name": "A", "type": "FLOAT", "description": "A"},
+            {"mode": "NULLABLE", "name": "B", "type": "FLOAT", "description": "B"},
+            {"mode": "NULLABLE", "name": "C", "type": "STRING", "description": "C"},
+        ]
+    }
+
+    gbq_table.create(table_id, table_schema)
+    gbq.to_gbq(
+        pandas.DataFrame({"A": [1.0], "B": [2.0], "C": ["a"]}),
+        "{0}.{1}".format(gbq_table.dataset_id, table_id),
+        project_id=gbq_connector.project_id,
+        if_exists="append",
+    )
+
+    assert verify_schema(gbq_connector, gbq_table.dataset_id, table_id, table_schema)
+
+
+def test_gbqconnector_init_with_bq_client(bigquery_client):
+    gbq_connector = gbq.GbqConnector(
+        project_id="project_id", credentials=None, bigquery_client=bigquery_client
+    )
+
+    assert gbq_connector.project_id == bigquery_client.project
+    assert gbq_connector.credentials is bigquery_client._credentials
+    assert gbq_connector.client is bigquery_client
diff --git a/packages/pandas-gbq/tests/system/test_read_gbq.py b/packages/pandas-gbq/tests/system/test_read_gbq.py
new file mode 100644
index 000000000000..946da668ba81
--- /dev/null
+++ b/packages/pandas-gbq/tests/system/test_read_gbq.py
@@ -0,0 +1,674 @@
+# Copyright (c) 2021 pandas-gbq Authors All rights reserved.
+# Use of this source code is governed by a BSD-style
+# license that can be found in the LICENSE file.
+
+import collections
+import datetime
+import decimal
+import random
+
+import db_dtypes
+from google.cloud import bigquery
+import packaging.version
+import pandas
+import pandas.testing
+import pytest
+
+from pandas_gbq.features import FEATURES
+
+QueryTestCase = collections.namedtuple(
+    "QueryTestCase",
+    ["query", "expected", "use_bqstorage_apis"],
+    defaults=[None, None, {True, False}],
+)
+
+
+@pytest.fixture
+def writable_table(
+    bigquery_client: bigquery.Client, project_id: str, random_dataset: bigquery.Dataset
+):
+    full_table_id = f"{project_id}.{random_dataset.dataset_id}.writable_table_{random.randrange(1_000_000_000)}"
+    table = bigquery.Table(full_table_id)
+    table.schema = [
+        bigquery.SchemaField("field1", "STRING"),
+        bigquery.SchemaField("field2", "INTEGER"),
+    ]
+    bigquery_client.create_table(table)
+    yield full_table_id
+    bigquery_client.delete_table(full_table_id)
+
+
+@pytest.mark.skipif(
+    packaging.version.parse(pandas.__version__).release >= (2, 0), reason=""
+)
+@pytest.mark.parametrize(["use_bqstorage_api"], [(True,), (False,)])
+@pytest.mark.parametrize(
+    ["query", "expected", "use_bqstorage_apis"],
+    [
+        pytest.param(
+            *QueryTestCase(
+                query="""
+SELECT
+  bools.row_num AS row_num,
+  bool_col,
+  bytes_col,
+  date_col,
+  datetime_col,
+  float_col,
+  int64_col,
+  numeric_col,
+  string_col,
+  time_col,
+  timestamp_col
+FROM
+  UNNEST([
+      STRUCT(1 AS row_num, TRUE AS bool_col),
+      STRUCT(2 AS row_num, FALSE AS bool_col),
+      STRUCT(3 AS row_num, TRUE AS bool_col) ]) AS `bools`
+INNER JOIN
+  UNNEST([
+      STRUCT(1 AS row_num, CAST('C00010FF' AS BYTES FORMAT 'HEX') AS bytes_col),
+      STRUCT(2 AS row_num, CAST('F1AC' AS BYTES FORMAT 'HEX') AS bytes_col),
+      STRUCT(3 AS row_num, CAST('FFBADD11' AS BYTES FORMAT 'HEX') AS bytes_co) ]) AS `bytes`
+INNER JOIN
+  UNNEST([
+      STRUCT(1 AS row_num, DATE(1998, 9, 4) AS date_col),
+      STRUCT(2 AS row_num, DATE(2011, 10, 1) AS date_col),
+      STRUCT(3 AS row_num, DATE(2018, 4, 11) AS date_col) ]) AS `dates`
+INNER JOIN
+  UNNEST([
+      STRUCT(1 AS row_num, DATETIME('1998-09-04 12:34:56.789101') AS datetime_col),
+      STRUCT(2 AS row_num, DATETIME('2011-10-01 00:01:02.345678') AS datetime_col),
+      STRUCT(3 AS row_num, DATETIME('2018-04-11 23:59:59.999999') AS datetime_col) ]) AS `datetimes`
+INNER JOIN
+  UNNEST([
+      STRUCT(1 AS row_num, 1.125 AS float_col),
+      STRUCT(2 AS row_num, -2.375 AS float_col),
+      STRUCT(3 AS row_num, 0.0 AS float_col) ]) AS `floats`
+INNER JOIN
+  UNNEST([
+      -- 2 ^ 63 - 1, but in hex to avoid intermediate overlfow.
+      STRUCT(1 AS row_num, 0x7fffffffffffffff AS int64_col),
+      STRUCT(2 AS row_num, -1 AS in64_col),
+      -- -2 ^ 63, but in hex to avoid intermediate overlfow.
+      STRUCT(3 AS row_num, -0x8000000000000000 AS int64_col) ]) AS `ints`
+INNER JOIN
+  UNNEST([
+      STRUCT(1 AS row_num, CAST('123.456789' AS NUMERIC) AS numeric_col),
+      STRUCT(2 AS row_num, CAST('-123.456789' AS NUMERIC) AS numeric_col),
+      STRUCT(3 AS row_num, CAST('999.999999' AS NUMERIC) AS numeric_col) ]) AS `numerics`
+INNER JOIN
+  UNNEST([
+      STRUCT(1 AS row_num, 'abcdefghijklmnopqrstuvwxyz' AS string_col),
+      STRUCT(2 AS row_num, 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' AS string_col),
+      STRUCT(3 AS row_num, 'こんにちは' AS string_col) ]) AS `strings`
+INNER JOIN
+  UNNEST([
+      STRUCT(1 AS row_num, CAST('00:00:00.000000' AS TIME) AS time_col),
+      STRUCT(2 AS row_num, CAST('09:08:07.654321' AS TIME) AS time_col),
+      STRUCT(3 AS row_num, CAST('23:59:59.999999' AS TIME) AS time_col) ]) AS `times`
+INNER JOIN
+  UNNEST([
+      STRUCT(1 AS row_num, TIMESTAMP('1998-09-04 12:34:56.789101') AS timestamp_col),
+      STRUCT(2 AS row_num, TIMESTAMP('2011-10-01 00:01:02.345678') AS timestamp_col),
+      STRUCT(3 AS row_num, TIMESTAMP('2018-04-11 23:59:59.999999') AS timestamp_col) ]) AS `timestamps`
+WHERE
+  `bools`.row_num = `dates`.row_num
+  AND `bools`.row_num = `bytes`.row_num
+  AND `bools`.row_num = `datetimes`.row_num
+  AND `bools`.row_num = `floats`.row_num
+  AND `bools`.row_num = `ints`.row_num
+  AND `bools`.row_num = `numerics`.row_num
+  AND `bools`.row_num = `strings`.row_num
+  AND `bools`.row_num = `times`.row_num
+  AND `bools`.row_num = `timestamps`.row_num
+ORDER BY row_num ASC
+                """,
+                expected=pandas.DataFrame(
+                    {
+                        "row_num": pandas.Series([1, 2, 3], dtype="Int64"),
+                        "bool_col": pandas.Series(
+                            [True, False, True],
+                            dtype="boolean"
+                            if FEATURES.pandas_has_boolean_dtype
+                            else "bool",
+                        ),
+                        "bytes_col": [
+                            bytes.fromhex("C00010FF"),
+                            bytes.fromhex("F1AC"),
+                            bytes.fromhex("FFBADD11"),
+                        ],
+                        "date_col": pandas.Series(
+                            [
+                                datetime.date(1998, 9, 4),
+                                datetime.date(2011, 10, 1),
+                                datetime.date(2018, 4, 11),
+                            ],
+                            dtype=db_dtypes.DateDtype(),
+                        ),
+                        "datetime_col": pandas.Series(
+                            [
+                                "1998-09-04 12:34:56.789101",
+                                "2011-10-01 00:01:02.345678",
+                                "2018-04-11 23:59:59.999999",
+                            ],
+                            dtype="datetime64[ns]",
+                        ),
+                        "float_col": [1.125, -2.375, 0.0],
+                        "int64_col": pandas.Series(
+                            [(2**63) - 1, -1, -(2**63)], dtype="Int64"
+                        ),
+                        "numeric_col": [
+                            decimal.Decimal("123.456789"),
+                            decimal.Decimal("-123.456789"),
+                            decimal.Decimal("999.999999"),
+                        ],
+                        "string_col": [
+                            "abcdefghijklmnopqrstuvwxyz",
+                            "ABCDEFGHIJKLMNOPQRSTUVWXYZ",
+                            "こんにちは",
+                        ],
+                        "time_col": pandas.Series(
+                            ["00:00:00.000000", "09:08:07.654321", "23:59:59.999999"],
+                            dtype=db_dtypes.TimeDtype(),
+                        ),
+                        "timestamp_col": pandas.Series(
+                            [
+                                "1998-09-04 12:34:56.789101",
+                                "2011-10-01 00:01:02.345678",
+                                "2018-04-11 23:59:59.999999",
+                            ],
+                            dtype="datetime64[ns]",
+                        ).dt.tz_localize(datetime.timezone.utc),
+                    }
+                ),
+            ),
+            id="scalar-types-nonnull-normal-range",
+        ),
+        pytest.param(
+            *QueryTestCase(
+                query="""
+SELECT
+  bools.row_num AS row_num,
+  bool_col,
+  bytes_col,
+  date_col,
+  datetime_col,
+  float_col,
+  int64_col,
+  numeric_col,
+  string_col,
+  time_col,
+  timestamp_col
+FROM
+  UNNEST([
+      STRUCT(1 AS row_num, TRUE AS bool_col),
+      STRUCT(2 AS row_num, FALSE AS bool_col),
+      STRUCT(3 AS row_num, NULL AS bool_col) ]) AS `bools`
+INNER JOIN
+  UNNEST([
+      STRUCT(1 AS row_num, NULL AS bytes_col),
+      STRUCT(2 AS row_num, CAST('F1AC' AS BYTES FORMAT 'HEX') AS bytes_col),
+      STRUCT(3 AS row_num, CAST('' AS BYTES FORMAT 'HEX') AS bytes_co) ]) AS `bytes`
+INNER JOIN
+  UNNEST([
+      STRUCT(1 AS row_num, DATE(1970, 1, 1) AS date_col),
+      STRUCT(2 AS row_num, NULL AS date_col),
+      STRUCT(3 AS row_num, DATE(2018, 4, 11) AS date_col) ]) AS `dates`
+INNER JOIN
+  UNNEST([
+      STRUCT(1 AS row_num, DATETIME('1970-01-01 00:00:00.000000') AS datetime_col),
+      STRUCT(2 AS row_num, DATETIME('2011-10-01 00:01:02.345678') AS datetime_col),
+      STRUCT(3 AS row_num, NULL AS datetime_col) ]) AS `datetimes`
+INNER JOIN
+  UNNEST([
+      STRUCT(1 AS row_num, NULL AS float_col),
+      STRUCT(2 AS row_num, -2.375 AS float_col),
+      STRUCT(3 AS row_num, 0.0 AS float_col) ]) AS `floats`
+INNER JOIN
+  UNNEST([
+      STRUCT(1 AS row_num, -1 AS int64_col),
+      STRUCT(2 AS row_num, NULL AS int64_col),
+      STRUCT(3 AS row_num, 0 AS int64_col) ]) AS `int64s`
+INNER JOIN
+  UNNEST([
+      STRUCT(1 AS row_num, CAST('123.456789' AS NUMERIC) AS numeric_col),
+      STRUCT(2 AS row_num, NULL AS numeric_col),
+      STRUCT(3 AS row_num, CAST('999.999999' AS NUMERIC) AS numeric_col) ]) AS `numerics`
+INNER JOIN
+  UNNEST([
+      STRUCT(1 AS row_num, '' AS string_col),
+      STRUCT(2 AS row_num, 'こんにちは' AS string_col),
+      STRUCT(3 AS row_num, NULL AS string_col) ]) AS `strings`
+INNER JOIN
+  UNNEST([
+      STRUCT(1 AS row_num, NULL AS time_col),
+      STRUCT(2 AS row_num, CAST('00:00:00.000000' AS TIME) AS time_col),
+      STRUCT(3 AS row_num, CAST('23:59:59.999999' AS TIME) AS time_col) ]) AS `times`
+INNER JOIN
+  UNNEST([
+      STRUCT(1 AS row_num, TIMESTAMP('1970-01-01 00:00:00.000000') AS timestamp_col),
+      STRUCT(2 AS row_num, NULL AS timestamp_col),
+      STRUCT(3 AS row_num, TIMESTAMP('2018-04-11 23:59:59.999999') AS timestamp_col) ]) AS `timestamps`
+WHERE
+  `bools`.row_num = `dates`.row_num
+  AND `bools`.row_num = `bytes`.row_num
+  AND `bools`.row_num = `datetimes`.row_num
+  AND `bools`.row_num = `floats`.row_num
+  AND `bools`.row_num = `int64s`.row_num
+  AND `bools`.row_num = `numerics`.row_num
+  AND `bools`.row_num = `strings`.row_num
+  AND `bools`.row_num = `times`.row_num
+  AND `bools`.row_num = `timestamps`.row_num
+ORDER BY row_num ASC
+            """,
+                expected=pandas.DataFrame(
+                    {
+                        "row_num": pandas.Series([1, 2, 3], dtype="Int64"),
+                        "bool_col": pandas.Series(
+                            [True, False, None],
+                            dtype="boolean"
+                            if FEATURES.pandas_has_boolean_dtype
+                            else "object",
+                        ),
+                        "bytes_col": [None, bytes.fromhex("F1AC"), b""],
+                        "date_col": pandas.Series(
+                            [
+                                datetime.date(1970, 1, 1),
+                                None,
+                                datetime.date(2018, 4, 11),
+                            ],
+                            dtype=db_dtypes.DateDtype(),
+                        ),
+                        "datetime_col": pandas.Series(
+                            [
+                                "1970-01-01 00:00:00.000000",
+                                "2011-10-01 00:01:02.345678",
+                                None,
+                            ],
+                            dtype="datetime64[ns]",
+                        ),
+                        "float_col": [None, -2.375, 0.0],
+                        "int64_col": pandas.Series([-1, None, 0], dtype="Int64"),
+                        "numeric_col": [
+                            decimal.Decimal("123.456789"),
+                            None,
+                            decimal.Decimal("999.999999"),
+                        ],
+                        "string_col": ["", "こんにちは", None],
+                        "time_col": pandas.Series(
+                            [None, "00:00:00", "23:59:59.999999"],
+                            dtype=db_dtypes.TimeDtype(),
+                        ),
+                        "timestamp_col": pandas.Series(
+                            [
+                                "1970-01-01 00:00:00.000000",
+                                None,
+                                "2018-04-11 23:59:59.999999",
+                            ],
+                            dtype="datetime64[ns]",
+                        ).dt.tz_localize(datetime.timezone.utc),
+                    }
+                ),
+            ),
+            id="scalar-types-nullable-normal-range",
+        ),
+        pytest.param(
+            *QueryTestCase(
+                query="""
+SELECT
+  bools.row_num AS row_num,
+  bool_col,
+  bytes_col,
+  date_col,
+  datetime_col,
+  float_col,
+  int64_col,
+  numeric_col,
+  string_col,
+  time_col,
+  timestamp_col
+FROM
+  UNNEST([
+      STRUCT(1 AS row_num, CAST(NULL AS BOOL) AS bool_col) ]) AS `bools`
+INNER JOIN
+  UNNEST([
+      STRUCT(1 AS row_num, CAST(NULL AS BYTES) AS bytes_col) ]) AS `bytes`
+INNER JOIN
+  UNNEST([
+      STRUCT(1 AS row_num, CAST(NULL AS DATE) AS date_col) ]) AS `dates`
+INNER JOIN
+  UNNEST([
+      STRUCT(1 AS row_num, CAST(NULL AS DATETIME) AS datetime_col) ]) AS `datetimes`
+INNER JOIN
+  UNNEST([
+      STRUCT(1 AS row_num, CAST(NULL AS FLOAT64) AS float_col) ]) AS `floats`
+INNER JOIN
+  UNNEST([
+      STRUCT(1 AS row_num, CAST(NULL AS INT64) AS int64_col) ]) AS `int64s`
+INNER JOIN
+  UNNEST([
+      STRUCT(1 AS row_num, CAST(NULL AS NUMERIC) AS numeric_col) ]) AS `numerics`
+INNER JOIN
+  UNNEST([
+      STRUCT(1 AS row_num, CAST(NULL AS STRING) AS string_col) ]) AS `strings`
+INNER JOIN
+  UNNEST([
+      STRUCT(1 AS row_num, CAST(NULL AS TIME) AS time_col) ]) AS `times`
+INNER JOIN
+  UNNEST([
+      STRUCT(1 AS row_num, CAST(NULL AS TIMESTAMP) AS timestamp_col) ]) AS `timestamps`
+WHERE
+  `bools`.row_num = `dates`.row_num
+  AND `bools`.row_num = `bytes`.row_num
+  AND `bools`.row_num = `datetimes`.row_num
+  AND `bools`.row_num = `floats`.row_num
+  AND `bools`.row_num = `int64s`.row_num
+  AND `bools`.row_num = `numerics`.row_num
+  AND `bools`.row_num = `strings`.row_num
+  AND `bools`.row_num = `times`.row_num
+  AND `bools`.row_num = `timestamps`.row_num
+ORDER BY row_num ASC
+            """,
+                expected=pandas.DataFrame(
+                    {
+                        "row_num": pandas.Series([1], dtype="Int64"),
+                        "bool_col": pandas.Series(
+                            [None],
+                            dtype="boolean"
+                            if FEATURES.pandas_has_boolean_dtype
+                            else "object",
+                        ),
+                        "bytes_col": [None],
+                        "date_col": pandas.Series(
+                            [None],
+                            dtype=db_dtypes.DateDtype(),
+                        ),
+                        "datetime_col": pandas.Series(
+                            [None],
+                            dtype="datetime64[ns]",
+                        ),
+                        "float_col": pandas.Series([None], dtype="float64"),
+                        "int64_col": pandas.Series([None], dtype="Int64"),
+                        "numeric_col": [None],
+                        "string_col": [None],
+                        "time_col": pandas.Series(
+                            [None],
+                            dtype=db_dtypes.TimeDtype(),
+                        ),
+                        "timestamp_col": pandas.Series(
+                            [None],
+                            dtype="datetime64[ns]",
+                        ).dt.tz_localize(datetime.timezone.utc),
+                    }
+                ),
+            ),
+            id="scalar-types-null",
+        ),
+        pytest.param(
+            *QueryTestCase(
+                query="""
+SELECT
+  bignumerics.row_num AS row_num,
+  bignumeric_col,
+  nullable_col,
+  null_col
+FROM
+  UNNEST([
+      STRUCT(1 AS row_num, CAST('123456789.123456789' AS BIGNUMERIC) AS bignumeric_col),
+      STRUCT(2 AS row_num, CAST('-123456789.123456789' AS BIGNUMERIC) AS bignumeric_col),
+      STRUCT(3 AS row_num, CAST('987654321.987654321' AS BIGNUMERIC) AS bignumeric_col) ]) AS `bignumerics`
+INNER JOIN
+  UNNEST([
+      STRUCT(1 AS row_num, CAST('123456789.123456789' AS BIGNUMERIC) AS nullable_col),
+      STRUCT(2 AS row_num, NULL AS nullable_col),
+      STRUCT(3 AS row_num, CAST('987654321.987654321' AS BIGNUMERIC) AS nullable_col) ]) AS `nullables`
+INNER JOIN
+  UNNEST([
+      STRUCT(1 AS row_num, CAST(NULL AS BIGNUMERIC) AS null_col),
+      STRUCT(2 AS row_num, CAST(NULL AS BIGNUMERIC) AS null_col),
+      STRUCT(3 AS row_num, CAST(NULL AS BIGNUMERIC) AS null_col) ]) AS `nulls`
+WHERE
+  `bignumerics`.row_num = `nullables`.row_num
+  AND `bignumerics`.row_num = `nulls`.row_num
+ORDER BY row_num ASC
+            """,
+                expected=pandas.DataFrame(
+                    {
+                        "row_num": pandas.Series([1, 2, 3], dtype="Int64"),
+                        # TODO: Support a special (nullable) dtype for decimal data.
+                        # https://github.com/googleapis/python-db-dtypes-pandas/issues/49
+                        "bignumeric_col": [
+                            decimal.Decimal("123456789.123456789"),
+                            decimal.Decimal("-123456789.123456789"),
+                            decimal.Decimal("987654321.987654321"),
+                        ],
+                        "nullable_col": [
+                            decimal.Decimal("123456789.123456789"),
+                            None,
+                            decimal.Decimal("987654321.987654321"),
+                        ],
+                        "null_col": [None, None, None],
+                    }
+                ),
+            ),
+            id="bignumeric-normal-range",
+        ),
+        pytest.param(
+            *QueryTestCase(
+                query="""
+SELECT
+  dates.row_num AS row_num,
+  date_col,
+  datetime_col,
+  timestamp_col
+FROM
+  UNNEST([
+      STRUCT(1 AS row_num, DATE(1, 1, 1) AS date_col),
+      STRUCT(2 AS row_num, DATE(9999, 12, 31) AS date_col),
+      STRUCT(3 AS row_num, DATE(2262, 4, 12) AS date_col) ]) AS `dates`
+INNER JOIN
+  UNNEST([
+      STRUCT(1 AS row_num, DATETIME('0001-01-01 00:00:00.000000') AS datetime_col),
+      STRUCT(2 AS row_num, DATETIME('9999-12-31 23:59:59.999999') AS datetime_col),
+      STRUCT(3 AS row_num, DATETIME('2262-04-11 23:47:16.854776') AS datetime_col) ]) AS `datetimes`
+INNER JOIN
+  UNNEST([
+      STRUCT(1 AS row_num, TIMESTAMP('0001-01-01 00:00:00.000000') AS timestamp_col),
+      STRUCT(2 AS row_num, TIMESTAMP('9999-12-31 23:59:59.999999') AS timestamp_col),
+      STRUCT(3 AS row_num, TIMESTAMP('2262-04-11 23:47:16.854776') AS timestamp_col) ]) AS `timestamps`
+WHERE
+  `dates`.row_num = `datetimes`.row_num
+  AND `dates`.row_num = `timestamps`.row_num
+ORDER BY row_num ASC
+            """,
+                expected=pandas.DataFrame(
+                    {
+                        "row_num": pandas.Series([1, 2, 3], dtype="Int64"),
+                        "date_col": pandas.Series(
+                            [
+                                datetime.date(1, 1, 1),
+                                datetime.date(9999, 12, 31),
+                                datetime.date(2262, 4, 12),
+                            ],
+                            dtype="object",
+                        ),
+                        "datetime_col": pandas.Series(
+                            [
+                                datetime.datetime(1, 1, 1, 0, 0, 0, 0),
+                                datetime.datetime(9999, 12, 31, 23, 59, 59, 999999),
+                                # One microsecond more than pandas.Timestamp.max.
+                                datetime.datetime(2262, 4, 11, 23, 47, 16, 854776),
+                            ],
+                            dtype="object",
+                        ),
+                        "timestamp_col": pandas.Series(
+                            [
+                                datetime.datetime(
+                                    1, 1, 1, 0, 0, 0, 0, tzinfo=datetime.timezone.utc
+                                ),
+                                datetime.datetime(
+                                    9999,
+                                    12,
+                                    31,
+                                    23,
+                                    59,
+                                    59,
+                                    999999,
+                                    tzinfo=datetime.timezone.utc,
+                                ),
+                                # One microsecond more than pandas.Timestamp.max.
+                                datetime.datetime(
+                                    2262,
+                                    4,
+                                    11,
+                                    23,
+                                    47,
+                                    16,
+                                    854776,
+                                    tzinfo=datetime.timezone.utc,
+                                ),
+                            ],
+                            dtype="object",
+                        ),
+                    }
+                ),
+                use_bqstorage_apis={True, False},
+            ),
+            id="issue365-extreme-datetimes",
+        ),
+    ],
+)
+def test_default_dtypes(
+    read_gbq, query, expected, use_bqstorage_apis, use_bqstorage_api
+):
+    if use_bqstorage_api not in use_bqstorage_apis:
+        pytest.skip(f"use_bqstorage_api={use_bqstorage_api} not supported.")
+    # the parameter useQueryCache=False is used in the following function call
+    # to avoid a failing test due to cached data that may be out of order.
+    result = read_gbq(
+        query,
+        use_bqstorage_api=use_bqstorage_api,
+        configuration={"query": {"useQueryCache": False}},
+    )
+    pandas.testing.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize(["use_bqstorage_api"], [(True,), (False,)])
+def test_empty_dataframe(read_gbq, use_bqstorage_api):
+    # Bug fix for https://github.com/pandas-dev/pandas/issues/10273 and
+    # https://github.com/googleapis/python-bigquery-pandas/issues/299
+    query = """
+SELECT
+  bools.row_num AS row_num,
+  bool_col,
+  bytes_col,
+  date_col,
+  datetime_col,
+  float_col,
+  int64_col,
+  numeric_col,
+  string_col,
+  time_col,
+  timestamp_col
+FROM
+  UNNEST([
+      STRUCT(1 AS row_num, TRUE AS bool_col) ]) AS `bools`
+INNER JOIN
+  UNNEST([
+      STRUCT(1 AS row_num, CAST('F1AC' AS BYTES FORMAT 'HEX') AS bytes_col) ]) AS `bytes`
+INNER JOIN
+  UNNEST([
+      STRUCT(1 AS row_num, DATE(2018, 4, 11) AS date_col) ]) AS `dates`
+INNER JOIN
+  UNNEST([
+      STRUCT(1 AS row_num, DATETIME('2011-10-01 00:01:02.345678') AS datetime_col) ]) AS `datetimes`
+INNER JOIN
+  UNNEST([
+      STRUCT(1 AS row_num, -2.375 AS float_col) ]) AS `floats`
+INNER JOIN
+  UNNEST([
+      STRUCT(1 AS row_num, 1234 AS int64_col) ]) AS `int64s`
+INNER JOIN
+  UNNEST([
+      STRUCT(1 AS row_num, CAST('123.456789' AS NUMERIC) AS numeric_col) ]) AS `numerics`
+INNER JOIN
+  UNNEST([
+      STRUCT(1 AS row_num, 'abcdefghijklmnopqrstuvwxyz' AS string_col) ]) AS `strings`
+INNER JOIN
+  UNNEST([
+      STRUCT(1 AS row_num, CAST('09:08:07.654321' AS TIME) AS time_col) ]) AS `times`
+INNER JOIN
+  UNNEST([
+      STRUCT(1 AS row_num, TIMESTAMP('1998-09-04 12:34:56.789101') AS timestamp_col) ]) AS `timestamps`
+WHERE
+  `bools`.row_num = `dates`.row_num
+  AND `bools`.row_num = `bytes`.row_num
+  AND `bools`.row_num = `datetimes`.row_num
+  AND `bools`.row_num = `floats`.row_num
+  AND `bools`.row_num = `int64s`.row_num
+  AND `bools`.row_num = `numerics`.row_num
+  AND `bools`.row_num = `strings`.row_num
+  AND `bools`.row_num = `times`.row_num
+  AND `bools`.row_num = `timestamps`.row_num
+  AND `bools`.row_num = -1
+ORDER BY row_num ASC
+    """
+    expected = pandas.DataFrame(
+        {
+            "row_num": pandas.Series([], dtype="Int64"),
+            "bool_col": pandas.Series(
+                [],
+                dtype="boolean" if FEATURES.pandas_has_boolean_dtype else "bool",
+            ),
+            "bytes_col": pandas.Series([], dtype="object"),
+            "date_col": pandas.Series(
+                [],
+                dtype=db_dtypes.DateDtype(),
+            ),
+            "datetime_col": pandas.Series(
+                [],
+                dtype="datetime64[ns]",
+            ),
+            "float_col": pandas.Series([], dtype="float64"),
+            "int64_col": pandas.Series([], dtype="Int64"),
+            "numeric_col": pandas.Series([], dtype="object"),
+            "string_col": pandas.Series([], dtype="object"),
+            "time_col": pandas.Series(
+                [],
+                dtype=db_dtypes.TimeDtype(),
+            ),
+            "timestamp_col": pandas.Series(
+                [],
+                dtype="datetime64[ns]",
+            ).dt.tz_localize(datetime.timezone.utc),
+        }
+    )
+    result = read_gbq(query, use_bqstorage_api=use_bqstorage_api)
+    pandas.testing.assert_frame_equal(
+        result, expected, check_index_type=False, check_dtype=False
+    )
+
+
+def test_dml_query(read_gbq, writable_table: str):
+    query = f"""
+    UPDATE `{writable_table}`
+    SET field1 = NULL
+    WHERE field1 = 'string';
+    UPDATE `{writable_table}`
+    SET field2 = NULL
+    WHERE field2 < 0;
+    """
+    result = read_gbq(query)
+    assert result is not None
+
+
+def test_read_gbq_with_bq_client(read_gbq_with_bq_client):
+    query = "SELECT * FROM UNNEST([1, 2, 3]) AS numbers"
+
+    actual_result = read_gbq_with_bq_client(query)
+
+    expected_result = pandas.DataFrame(
+        {"numbers": pandas.Series([1, 2, 3], dtype="Int64")}
+    )
+    pandas.testing.assert_frame_equal(actual_result, expected_result)
diff --git a/packages/pandas-gbq/tests/system/test_read_gbq_with_bqstorage.py b/packages/pandas-gbq/tests/system/test_read_gbq_with_bqstorage.py
new file mode 100644
index 000000000000..70dfecf45dfd
--- /dev/null
+++ b/packages/pandas-gbq/tests/system/test_read_gbq_with_bqstorage.py
@@ -0,0 +1,76 @@
+# Copyright (c) 2017 pandas-gbq Authors All rights reserved.
+# Use of this source code is governed by a BSD-style
+# license that can be found in the LICENSE file.
+
+"""System tests for read_gbq using the BigQuery Storage API."""
+
+import functools
+import uuid
+
+import pytest
+
+pytest.importorskip("google.cloud.bigquery", minversion="1.24.0")
+
+
+@pytest.fixture
+def method_under_test(project_id, credentials):
+    import pandas_gbq
+
+    return functools.partial(
+        pandas_gbq.read_gbq, project_id=project_id, credentials=credentials
+    )
+
+
+@pytest.mark.parametrize(
+    "query_string",
+    (
+        ("SELECT * FROM (SELECT 1) WHERE TRUE = FALSE;"),
+        (
+            "SELECT * FROM (SELECT TIMESTAMP('2020-02-11 16:33:32-06:00')) WHERE TRUE = FALSE;"
+        ),
+    ),
+)
+def test_empty_results(method_under_test, query_string):
+    """Test with an empty dataframe.
+
+    See: https://github.com/pydata/pandas-gbq/issues/299
+    """
+    df = method_under_test(
+        query_string,
+        use_bqstorage_api=True,
+    )
+    assert len(df.index) == 0
+
+
+def test_large_results(random_dataset, method_under_test):
+    df = method_under_test(
+        """
+        SELECT
+          total_amount,
+          passenger_count,
+          trip_distance
+        FROM `bigquery-public-data.new_york.tlc_green_trips_2014`
+        -- Select non-null rows for no-copy conversion from Arrow to pandas.
+        WHERE total_amount IS NOT NULL
+          AND passenger_count IS NOT NULL
+          AND trip_distance IS NOT NULL
+        LIMIT 10000000
+        """,
+        use_bqstorage_api=True,
+        configuration={
+            "query": {
+                "destinationTable": {
+                    "projectId": random_dataset.project,
+                    "datasetId": random_dataset.dataset_id,
+                    "tableId": "".join(
+                        [
+                            "test_read_gbq_w_bqstorage_api_",
+                            str(uuid.uuid4()).replace("-", "_"),
+                        ]
+                    ),
+                },
+                "writeDisposition": "WRITE_TRUNCATE",
+            }
+        },
+    )
+    assert len(df) == 10000000
diff --git a/packages/pandas-gbq/tests/system/test_sample.py b/packages/pandas-gbq/tests/system/test_sample.py
new file mode 100644
index 000000000000..7dbd89a50752
--- /dev/null
+++ b/packages/pandas-gbq/tests/system/test_sample.py
@@ -0,0 +1,97 @@
+# Copyright (c) 2025 pandas-gbq Authors All rights reserved.
+# Use of this source code is governed by a BSD-style
+# license that can be found in the LICENSE file.
+
+import google.cloud.bigquery
+import google.oauth2.credentials
+
+import pandas_gbq
+
+
+def test_sample_small_table(
+    project_id: str,
+    credentials: google.oauth2.credentials.Credentials,
+    bigquery_client: google.cloud.bigquery.Client,
+):
+    # Arrange
+    table_id = "bigquery-public-data.ml_datasets.penguins"
+    table = bigquery_client.get_table(table_id)
+    num_bytes = table.num_bytes
+    num_rows = table.num_rows
+
+    # Act
+    df = pandas_gbq.sample(
+        table_id,
+        target_mb=1_000,
+        credentials=credentials,
+        billing_project_id=project_id,
+    )
+
+    # Assert
+    assert num_bytes is not None and num_bytes > 0
+    assert num_rows is not None and num_rows > 0
+    assert df is not None and len(df.index) == num_rows
+
+
+def test_sample_large_table(
+    project_id: str,
+    credentials: google.oauth2.credentials.Credentials,
+    bigquery_client: google.cloud.bigquery.Client,
+):
+    # Arrange
+    table_id = "bigquery-public-data.chicago_taxi_trips.taxi_trips"
+    table = bigquery_client.get_table(table_id)
+    num_bytes = table.num_bytes
+    num_rows = table.num_rows
+
+    # Act
+    df = pandas_gbq.sample(
+        table_id, target_mb=10, credentials=credentials, billing_project_id=project_id
+    )
+
+    # Assert
+    assert num_bytes is not None and num_bytes > 0
+    assert num_rows is not None and num_rows > 0
+    assert df is not None
+    rows_downloaded = len(df.index)
+    assert rows_downloaded > 0
+    assert rows_downloaded < num_rows
+    bytes_downloaded = df.memory_usage().sum()
+    assert bytes_downloaded < num_bytes
+
+
+def test_sample_small_external_table(
+    project_id: str,
+    credentials: google.oauth2.credentials.Credentials,
+    external_table: str,
+):
+    # Act
+    df = pandas_gbq.sample(
+        external_table,
+        target_mb=1_000,
+        credentials=credentials,
+        billing_project_id=project_id,
+    )
+
+    # Assert
+    assert df is not None
+    rows_downloaded = len(df.index)
+    assert rows_downloaded > 0
+
+
+def test_sample_view(
+    project_id: str,
+    credentials: google.oauth2.credentials.Credentials,
+):
+    # Arrange
+    table_id = "bigquery-public-data.ethereum_blockchain.live_contracts"
+
+    # Act
+    df = pandas_gbq.sample(
+        table_id, target_mb=10, credentials=credentials, billing_project_id=project_id
+    )
+
+    # Assert
+    assert df is not None
+    rows_downloaded = len(df.index)
+    assert rows_downloaded > 0
diff --git a/packages/pandas-gbq/tests/system/test_to_gbq.py b/packages/pandas-gbq/tests/system/test_to_gbq.py
new file mode 100644
index 000000000000..ad7c58ecdd7f
--- /dev/null
+++ b/packages/pandas-gbq/tests/system/test_to_gbq.py
@@ -0,0 +1,631 @@
+# Copyright (c) 2017 pandas-gbq Authors All rights reserved.
+# Use of this source code is governed by a BSD-style
+# license that can be found in the LICENSE file.
+
+import collections
+import datetime
+import decimal
+import random
+
+import db_dtypes
+import pandas
+import pandas.testing
+import pyarrow
+import pytest
+
+pytest.importorskip("google.cloud.bigquery", minversion="1.24.0")
+
+
+@pytest.fixture(params=["load_parquet", "load_csv"])
+def api_method(request):
+    return request.param
+
+
+@pytest.fixture
+def method_under_test(to_gbq):
+    return to_gbq
+
+
+SeriesRoundTripTestCase = collections.namedtuple(
+    "SeriesRoundTripTestCase",
+    ["input_series", "api_methods", "expected_dtype"],
+    defaults=[None, {"load_csv", "load_parquet"}, None],
+)
+
+
+@pytest.mark.parametrize(
+    ["input_series", "api_methods", "expected_dtype"],
+    [
+        # Ensure that 64-bit floating point numbers are unchanged.
+        # See: https://github.com/pydata/pandas-gbq/issues/326
+        SeriesRoundTripTestCase(
+            input_series=pandas.Series(
+                [
+                    0.14285714285714285,
+                    0.4406779661016949,
+                    1.05148,
+                    1.05153,
+                    1.8571428571428572,
+                    2.718281828459045,
+                    3.141592653589793,
+                    2.0988936657440586e43,
+                ],
+                name="test_col",
+            ),
+        ),
+        pytest.param(
+            *SeriesRoundTripTestCase(
+                input_series=pandas.Series(
+                    [
+                        "abc",
+                        "defg",
+                        # Ensure that unicode characters are encoded. See:
+                        # https://github.com/googleapis/python-bigquery-pandas/issues/106
+                        "信用卡",
+                        "Skywalker™",
+                        "hülle",
+                    ],
+                    name="test_col",
+                ),
+            ),
+            id="string-unicode",
+        ),
+        pytest.param(
+            *SeriesRoundTripTestCase(
+                input_series=pandas.Series(
+                    [
+                        "abc",
+                        "defg",
+                        # Ensure that empty strings are written as empty string,
+                        # not NULL. See:
+                        # https://github.com/googleapis/python-bigquery-pandas/issues/366
+                        "",
+                        None,
+                    ],
+                    name="empty_strings",
+                ),
+                # BigQuery CSV loader uses empty string as the "null marker" by
+                # default. Potentially one could choose a rarely used character or
+                # string as the null marker to disambiguate null from empty string,
+                # but then that string couldn't be loaded.
+                # TODO: Revist when custom load job configuration is supported.
+                #       https://github.com/googleapis/python-bigquery-pandas/issues/425
+                api_methods={"load_parquet"},
+            ),
+            id="string-empty-and-null",
+        ),
+    ],
+)
+def test_series_round_trip(
+    method_under_test,
+    random_dataset_id,
+    read_gbq,
+    input_series,
+    api_method,
+    api_methods,
+    expected_dtype,
+):
+    if api_method not in api_methods:
+        pytest.skip(f"{api_method} not supported.")
+    table_id = f"{random_dataset_id}.round_trip_{random.randrange(1_000_000)}"
+    input_series = input_series.sort_values().reset_index(drop=True)
+    df = pandas.DataFrame(
+        # Some errors only occur in multi-column dataframes. See:
+        # https://github.com/googleapis/python-bigquery-pandas/issues/366
+        {"test_col": input_series, "test_col2": input_series}
+    )
+    method_under_test(df, table_id, api_method=api_method)
+
+    round_trip = read_gbq(table_id)
+    round_trip_series = round_trip["test_col"].sort_values().reset_index(drop=True)
+
+    expected_series = input_series.copy()
+    if expected_dtype is not None:
+        expected_series = expected_series.astype(expected_dtype)
+
+    pandas.testing.assert_series_equal(
+        round_trip_series,
+        expected_series,
+        check_exact=True,
+        check_names=False,
+    )
+
+
+DataFrameRoundTripTestCase = collections.namedtuple(
+    "DataFrameRoundTripTestCase",
+    ["input_df", "expected_df", "table_schema", "api_methods"],
+    defaults=[None, None, [], {"load_csv", "load_parquet"}],
+)
+
+DATAFRAME_ROUND_TRIPS = [
+    # Ensure that a BOOLEAN column can be written with bool, boolean, and
+    # object dtypes. See:
+    # https://github.com/googleapis/python-bigquery-pandas/issues/105
+    pytest.param(
+        *DataFrameRoundTripTestCase(
+            input_df=pandas.DataFrame(
+                {
+                    "row_num": [0, 1, 2],
+                    "bool_col": pandas.Series(
+                        [True, False, True],
+                        dtype="bool",
+                    ),
+                    "boolean_col": pandas.Series(
+                        [None, True, False],
+                        dtype="boolean",
+                    ),
+                    "object_col": pandas.Series(
+                        [False, None, True],
+                        dtype="object",
+                    ),
+                }
+            ),
+            table_schema=[
+                {"name": "bool_col", "type": "BOOLEAN"},
+                {"name": "boolean_col", "type": "BOOLEAN"},
+                {"name": "object_col", "type": "BOOLEAN"},
+            ],
+            api_methods={"load_csv", "load_parquet"},
+        ),
+        id="boolean",
+    ),
+    # Ensure that a DATE column can be written with datetime64[ns] dtype
+    # data. See:
+    # https://github.com/googleapis/python-bigquery-pandas/issues/362
+    DataFrameRoundTripTestCase(
+        input_df=pandas.DataFrame(
+            {
+                "row_num": [0, 1, 2],
+                "date_col": pandas.Series(
+                    ["2021-04-17", "1999-12-31", "2038-01-19"],
+                    dtype="datetime64[ns]",
+                ),
+            }
+        ),
+        table_schema=[{"name": "date_col", "type": "DATE"}],
+        # Skip CSV because the pandas CSV writer includes time when writing
+        # datetime64 values.
+        api_methods={"load_parquet"},
+    ),
+    DataFrameRoundTripTestCase(
+        input_df=pandas.DataFrame(
+            {
+                "row_num": [0, 1, 2],
+                "date_col": pandas.Series(
+                    ["2021-04-17", "1999-12-31", "2038-01-19"],
+                    dtype=db_dtypes.DateDtype(),
+                ),
+            }
+        ),
+        table_schema=[{"name": "date_col", "type": "DATE"}],
+    ),
+    # Loading a DATE column should work for string objects. See:
+    # https://github.com/googleapis/python-bigquery-pandas/issues/421
+    DataFrameRoundTripTestCase(
+        input_df=pandas.DataFrame(
+            {"row_num": [123], "date_col": ["2021-12-12"]},
+            columns=["row_num", "date_col"],
+        ),
+        expected_df=pandas.DataFrame(
+            {
+                "row_num": [123],
+                "date_col": pandas.Series(
+                    [datetime.date(2021, 12, 12)], dtype=db_dtypes.DateDtype()
+                ),
+            },
+            columns=["row_num", "date_col"],
+        ),
+        table_schema=[
+            {"name": "row_num", "type": "INTEGER"},
+            {"name": "date_col", "type": "DATE"},
+        ],
+    ),
+    # Loading an INTEGER column should work for any integer dtype. See:
+    # https://github.com/googleapis/python-bigquery-pandas/issues/616
+    pytest.param(
+        *DataFrameRoundTripTestCase(
+            input_df=pandas.DataFrame(
+                {
+                    "row_num": [0, 1, 2],
+                    "object": pandas.Series(
+                        [None, 1, -2],
+                        dtype="object",
+                    ),
+                    "nullable_int64": pandas.Series(
+                        [3, None, -4],
+                        dtype="Int64",
+                    ),
+                    "int8": pandas.Series(
+                        [5, -6, 7],
+                        dtype="int8",
+                    ),
+                    "int16": pandas.Series(
+                        [-8, 9, -10],
+                        dtype="int16",
+                    ),
+                    "int32": pandas.Series(
+                        [11, -12, 13],
+                        dtype="int32",
+                    ),
+                    "int64": pandas.Series(
+                        [-14, 15, -16],
+                        dtype="int64",
+                    ),
+                    "uint8": pandas.Series(
+                        [0, 1, 2],
+                        dtype="uint8",
+                    ),
+                    "uint16": pandas.Series(
+                        [3, 4, 5],
+                        dtype="uint16",
+                    ),
+                    "uint32": pandas.Series(
+                        [6, 7, 8],
+                        dtype="uint32",
+                    ),
+                }
+            ),
+            expected_df=pandas.DataFrame(
+                {
+                    "row_num": [0, 1, 2],
+                    "object": pandas.Series(
+                        [None, 1, -2],
+                        dtype="Int64",
+                    ),
+                    "nullable_int64": pandas.Series(
+                        [3, None, -4],
+                        dtype="Int64",
+                    ),
+                    "int8": pandas.Series(
+                        [5, -6, 7],
+                        dtype="Int64",
+                    ),
+                    "int16": pandas.Series(
+                        [-8, 9, -10],
+                        dtype="Int64",
+                    ),
+                    "int32": pandas.Series(
+                        [11, -12, 13],
+                        dtype="Int64",
+                    ),
+                    "int64": pandas.Series(
+                        [-14, 15, -16],
+                        dtype="Int64",
+                    ),
+                    "uint8": pandas.Series(
+                        [0, 1, 2],
+                        dtype="Int64",
+                    ),
+                    "uint16": pandas.Series(
+                        [3, 4, 5],
+                        dtype="Int64",
+                    ),
+                    "uint32": pandas.Series(
+                        [6, 7, 8],
+                        dtype="Int64",
+                    ),
+                }
+            ),
+            api_methods={"load_csv", "load_parquet"},
+        ),
+        id="integer",
+    ),
+    # Loading a NUMERIC column should work for floating point objects. See:
+    # https://github.com/googleapis/python-bigquery-pandas/issues/421
+    DataFrameRoundTripTestCase(
+        input_df=pandas.DataFrame(
+            {"row_num": [123], "num_col": [1.25]},
+            columns=["row_num", "num_col"],
+        ),
+        expected_df=pandas.DataFrame(
+            {"row_num": [123], "num_col": [decimal.Decimal("1.25")]},
+            columns=["row_num", "num_col"],
+        ),
+        table_schema=[
+            {"name": "row_num", "type": "INTEGER"},
+            {"name": "num_col", "type": "NUMERIC"},
+        ],
+    ),
+    pytest.param(
+        *DataFrameRoundTripTestCase(
+            input_df=pandas.DataFrame(
+                {
+                    "row_num": [1, 2, 3],
+                    # DATE valuess outside the pandas range for timestamp
+                    # aren't supported by the db-dtypes package.
+                    # https://github.com/googleapis/python-bigquery-pandas/issues/441
+                    "date_col": [
+                        datetime.date(1, 1, 1),
+                        datetime.date(1970, 1, 1),
+                        datetime.date(9999, 12, 31),
+                    ],
+                    # DATETIME values outside of the range for pandas timestamp
+                    # require `date_as_object` parameter in
+                    # google-cloud-bigquery versions 1.x and 2.x, but not 3.x.
+                    # https://github.com/googleapis/python-bigquery-pandas/issues/365
+                    "datetime_col": [
+                        datetime.datetime(1, 1, 1),
+                        datetime.datetime(1970, 1, 1),
+                        datetime.datetime(9999, 12, 31, 23, 59, 59, 999999),
+                    ],
+                    "timestamp_col": [
+                        datetime.datetime(1, 1, 1, tzinfo=datetime.timezone.utc),
+                        datetime.datetime(1970, 1, 1, tzinfo=datetime.timezone.utc),
+                        datetime.datetime(
+                            9999,
+                            12,
+                            31,
+                            23,
+                            59,
+                            59,
+                            999999,
+                            tzinfo=datetime.timezone.utc,
+                        ),
+                    ],
+                },
+                columns=["row_num", "date_col", "datetime_col", "timestamp_col"],
+            ),
+            table_schema=[
+                {"name": "row_num", "type": "INTEGER"},
+                {"name": "date_col", "type": "DATE"},
+                {"name": "datetime_col", "type": "DATETIME"},
+                {"name": "timestamp_col", "type": "TIMESTAMP"},
+            ],
+        ),
+        id="issue365-extreme-datetimes",
+    ),
+    # Loading a STRING column should work with all available string dtypes.
+    pytest.param(
+        *DataFrameRoundTripTestCase(
+            input_df=pandas.DataFrame(
+                {
+                    "row_num": [1, 2, 3],
+                    # If a cast to STRING is lossless, pandas-gbq should do that automatically.
+                    # See: https://github.com/googleapis/python-bigquery-pandas/issues/875
+                    "int_want_string": [94043, 10011, 98033],
+                    "object": pandas.Series(["a", "b", "c"], dtype="object"),
+                    "string_python": pandas.Series(
+                        ["d", "e", "f"],
+                        dtype=(
+                            pandas.StringDtype(storage="python")
+                            if hasattr(pandas, "ArrowDtype")
+                            else pandas.StringDtype()
+                        ),
+                    ),
+                    "string_pyarrow": pandas.Series(
+                        ["g", "h", "i"],
+                        dtype=(
+                            pandas.StringDtype(storage="pyarrow")
+                            if hasattr(pandas, "ArrowDtype")
+                            else pandas.StringDtype()
+                        ),
+                    ),
+                    "arrowdtype_string": pandas.Series(
+                        ["j", "k", "l"],
+                        dtype=(
+                            pandas.ArrowDtype(pyarrow.string())
+                            if hasattr(pandas, "ArrowDtype")
+                            else pandas.StringDtype()
+                        ),
+                    ),
+                    "arrowdtype_large_string": pandas.Series(
+                        ["m", "n", "o"],
+                        dtype=(
+                            pandas.ArrowDtype(pyarrow.large_string())
+                            if hasattr(pandas, "ArrowDtype")
+                            and hasattr(pyarrow, "large_string")
+                            else pandas.StringDtype()
+                        ),
+                    ),
+                },
+            ),
+            expected_df=pandas.DataFrame(
+                {
+                    "row_num": [1, 2, 3],
+                    "int_want_string": pandas.Series(
+                        ["94043", "10011", "98033"], dtype="object"
+                    ),
+                    "object": pandas.Series(["a", "b", "c"], dtype="object"),
+                    "string_python": pandas.Series(["d", "e", "f"], dtype="object"),
+                    "string_pyarrow": pandas.Series(["g", "h", "i"], dtype="object"),
+                    "arrowdtype_string": pandas.Series(["j", "k", "l"], dtype="object"),
+                    "arrowdtype_large_string": pandas.Series(
+                        ["m", "n", "o"], dtype="object"
+                    ),
+                },
+            ),
+            table_schema=[
+                {"name": "row_num", "type": "INTEGER"},
+                {"name": "int_want_string", "type": "STRING"},
+                {"name": "object", "type": "STRING"},
+                {"name": "string_python", "type": "STRING"},
+                {"name": "string_pyarrow", "type": "STRING"},
+                {"name": "string_pyarrow_from_int", "type": "STRING"},
+                {"name": "arrowdtype_string", "type": "STRING"},
+                {"name": "arrowdtype_large_string", "type": "STRING"},
+            ],
+        ),
+        id="issue875-strings",
+    ),
+    pytest.param(
+        # Load STRUCT and ARRAY using either object column or ArrowDtype.
+        # See: https://github.com/googleapis/python-bigquery-pandas/issues/452
+        *DataFrameRoundTripTestCase(
+            input_df=pandas.DataFrame(
+                {
+                    "row_num": [0, 1, 2],
+                    "object_struct": pandas.Series(
+                        [{"test": "str1"}, {"test": "str2"}, {"test": "str3"}],
+                        dtype="object",
+                    ),
+                    # Array of DATETIME requires inspection into list elements.
+                    # See:
+                    # https://github.com/googleapis/python-bigquery/pull/1061
+                    "object_array_datetime": pandas.Series(
+                        [[], [datetime.datetime(1998, 9, 4, 12, 0, 0)], []],
+                        dtype="object",
+                    ),
+                    "object_array_of_struct": pandas.Series(
+                        [[], [{"test": "str4"}], []], dtype="object"
+                    ),
+                    "arrow_struct": pandas.Series(
+                        [
+                            {"version": 1, "project": "pandas"},
+                            {"version": 2, "project": "pandas"},
+                            {"version": 1, "project": "numpy"},
+                        ],
+                        dtype=pandas.ArrowDtype(
+                            pyarrow.struct(
+                                [
+                                    ("version", pyarrow.int64()),
+                                    ("project", pyarrow.string()),
+                                ]
+                            )
+                        )
+                        if hasattr(pandas, "ArrowDtype")
+                        else "object",
+                    ),
+                    "arrow_array": pandas.Series(
+                        [[1, 2, 3], None, [4, 5, 6]],
+                        dtype=pandas.ArrowDtype(
+                            pyarrow.list_(pyarrow.int64()),
+                        )
+                        if hasattr(pandas, "ArrowDtype")
+                        else "object",
+                    ),
+                    "arrow_array_of_struct": pandas.Series(
+                        [
+                            [{"test": "str5"}],
+                            None,
+                            [{"test": "str6"}, {"test": "str7"}],
+                        ],
+                        dtype=pandas.ArrowDtype(
+                            pyarrow.list_(pyarrow.struct([("test", pyarrow.string())])),
+                        )
+                        if hasattr(pandas, "ArrowDtype")
+                        else "object",
+                    ),
+                },
+            ),
+            expected_df=pandas.DataFrame(
+                {
+                    "row_num": [0, 1, 2],
+                    "object_struct": pandas.Series(
+                        [{"test": "str1"}, {"test": "str2"}, {"test": "str3"}],
+                        dtype=pandas.ArrowDtype(
+                            pyarrow.struct([("test", pyarrow.string())]),
+                        )
+                        if hasattr(pandas, "ArrowDtype")
+                        else "object",
+                    ),
+                    # Array of DATETIME requires inspection into list elements.
+                    # See:
+                    # https://github.com/googleapis/python-bigquery/pull/1061
+                    "object_array_datetime": pandas.Series(
+                        [[], [datetime.datetime(1998, 9, 4, 12, 0, 0)], []],
+                        dtype=pandas.ArrowDtype(pyarrow.list_(pyarrow.timestamp("us")))
+                        if hasattr(pandas, "ArrowDtype")
+                        else "object",
+                    ),
+                    "object_array_of_struct": pandas.Series(
+                        [[], [{"test": "str4"}], []],
+                        dtype=pandas.ArrowDtype(
+                            pyarrow.list_(pyarrow.struct([("test", pyarrow.string())])),
+                        )
+                        if hasattr(pandas, "ArrowDtype")
+                        else "object",
+                    ),
+                    "arrow_struct": pandas.Series(
+                        [
+                            {"version": 1, "project": "pandas"},
+                            {"version": 2, "project": "pandas"},
+                            {"version": 1, "project": "numpy"},
+                        ],
+                        dtype=pandas.ArrowDtype(
+                            pyarrow.struct(
+                                [
+                                    ("version", pyarrow.int64()),
+                                    ("project", pyarrow.string()),
+                                ]
+                            )
+                        )
+                        if hasattr(pandas, "ArrowDtype")
+                        else "object",
+                    ),
+                    "arrow_array": pandas.Series(
+                        [[1, 2, 3], [], [4, 5, 6]],
+                        dtype=pandas.ArrowDtype(
+                            pyarrow.list_(pyarrow.int64()),
+                        )
+                        if hasattr(pandas, "ArrowDtype")
+                        else "object",
+                    ),
+                    "arrow_array_of_struct": pandas.Series(
+                        [[{"test": "str5"}], [], [{"test": "str6"}, {"test": "str7"}]],
+                        dtype=pandas.ArrowDtype(
+                            pyarrow.list_(pyarrow.struct([("test", pyarrow.string())])),
+                        )
+                        if hasattr(pandas, "ArrowDtype")
+                        else "object",
+                    ),
+                },
+            ),
+            api_methods={"load_parquet"},
+        ),
+        id="struct",
+    ),
+]
+
+
+@pytest.mark.parametrize(
+    ["input_df", "expected_df", "table_schema", "api_methods"], DATAFRAME_ROUND_TRIPS
+)
+def test_dataframe_round_trip_with_table_schema(
+    method_under_test,
+    read_gbq,
+    random_dataset_id,
+    input_df,
+    expected_df,
+    table_schema,
+    api_method,
+    api_methods,
+):
+    if api_method not in api_methods:
+        pytest.skip(f"{api_method} not supported.")
+    if expected_df is None:
+        expected_df = input_df
+    table_id = f"{random_dataset_id}.round_trip_w_schema_{random.randrange(1_000_000)}"
+    method_under_test(
+        input_df, table_id, table_schema=table_schema, api_method=api_method
+    )
+    round_trip = (
+        read_gbq(
+            table_id,
+            dtypes=dict(zip(expected_df.columns, expected_df.dtypes)),
+            # BigQuery Storage API is required to avoid out-of-bound due to extra
+            # day from rounding error which was fixed in google-cloud-bigquery
+            # 2.6.0. https://github.com/googleapis/python-bigquery/pull/402
+            use_bqstorage_api=True,
+        )
+        .set_index("row_num")
+        .sort_index()
+    )
+
+    # TODO(tswast): Support writing index columns if to_gbq(index=True).
+    pandas.testing.assert_frame_equal(
+        expected_df.set_index("row_num").sort_index(), round_trip
+    )
+
+
+def test_dataframe_round_trip_with_bq_client(
+    to_gbq_with_bq_client, read_gbq_with_bq_client, random_dataset_id
+):
+    table_id = (
+        f"{random_dataset_id}.round_trip_w_bq_client_{random.randrange(1_000_000)}"
+    )
+    df = pandas.DataFrame({"numbers": pandas.Series([1, 2, 3], dtype="Int64")})
+
+    to_gbq_with_bq_client(df, table_id)
+    result = read_gbq_with_bq_client(table_id)
+
+    pandas.testing.assert_frame_equal(result, df)
diff --git a/packages/pandas-gbq/tests/unit/__init__.py b/packages/pandas-gbq/tests/unit/__init__.py
new file mode 100644
index 000000000000..c9ab850639a6
--- /dev/null
+++ b/packages/pandas-gbq/tests/unit/__init__.py
@@ -0,0 +1,3 @@
+# Copyright (c) 2017 pandas-gbq Authors All rights reserved.
+# Use of this source code is governed by a BSD-style
+# license that can be found in the LICENSE file.
diff --git a/packages/pandas-gbq/tests/unit/conftest.py b/packages/pandas-gbq/tests/unit/conftest.py
new file mode 100644
index 000000000000..50a9ac1aa95b
--- /dev/null
+++ b/packages/pandas-gbq/tests/unit/conftest.py
@@ -0,0 +1,61 @@
+# Copyright (c) 2017 pandas-gbq Authors All rights reserved.
+# Use of this source code is governed by a BSD-style
+# license that can be found in the LICENSE file.
+
+# -*- coding: utf-8 -*-
+
+from unittest import mock
+
+import pytest
+
+
+def mock_get_credentials(*args, **kwargs):
+    import google.auth.credentials
+
+    mock_credentials = mock.create_autospec(google.auth.credentials.Credentials)
+    return mock_credentials, "default-project"
+
+
+@pytest.fixture
+def mock_service_account_credentials():
+    import google.oauth2.service_account
+
+    mock_credentials = mock.create_autospec(google.oauth2.service_account.Credentials)
+    return mock_credentials
+
+
+@pytest.fixture
+def mock_compute_engine_credentials():
+    import google.auth.compute_engine
+
+    mock_credentials = mock.create_autospec(google.auth.compute_engine.Credentials)
+    return mock_credentials
+
+
+@pytest.fixture(autouse=True)
+def no_auth(monkeypatch):
+    import pydata_google_auth
+
+    monkeypatch.setattr(pydata_google_auth, "default", mock_get_credentials)
+
+
+@pytest.fixture(autouse=True, scope="function")
+def reset_context():
+    import pandas_gbq
+
+    pandas_gbq.context.credentials = None
+    pandas_gbq.context.project = None
+
+
+@pytest.fixture(autouse=True)
+def mock_bigquery_client(monkeypatch):
+    import google.cloud.bigquery
+
+    mock_client = mock.create_autospec(google.cloud.bigquery.Client)
+    # Constructor returns the mock itself, so this mock can be treated as the
+    # constructor or the instance.
+    mock_client.return_value = mock_client
+    monkeypatch.setattr(google.cloud.bigquery, "Client", mock_client)
+    mock_client.reset_mock()
+
+    return mock_client
diff --git a/packages/pandas-gbq/tests/unit/schema/__init__.py b/packages/pandas-gbq/tests/unit/schema/__init__.py
new file mode 100644
index 000000000000..02d26e8e8fb8
--- /dev/null
+++ b/packages/pandas-gbq/tests/unit/schema/__init__.py
@@ -0,0 +1,3 @@
+# Copyright (c) 2024 pandas-gbq Authors All rights reserved.
+# Use of this source code is governed by a BSD-style
+# license that can be found in the LICENSE file.
diff --git a/packages/pandas-gbq/tests/unit/schema/test_pandas_to_bigquery.py b/packages/pandas-gbq/tests/unit/schema/test_pandas_to_bigquery.py
new file mode 100644
index 000000000000..4f3be85c2746
--- /dev/null
+++ b/packages/pandas-gbq/tests/unit/schema/test_pandas_to_bigquery.py
@@ -0,0 +1,231 @@
+# Copyright (c) 2019 pandas-gbq Authors All rights reserved.
+# Use of this source code is governed by a BSD-style
+# license that can be found in the LICENSE file.
+
+import collections
+import datetime
+import decimal
+import operator
+
+from google.cloud.bigquery import schema
+import pandas
+import pytest
+
+
+@pytest.fixture
+def module_under_test():
+    from pandas_gbq.schema import pandas_to_bigquery
+
+    return pandas_to_bigquery
+
+
+def test_dataframe_to_bigquery_fields_w_named_index(module_under_test):
+    df_data = collections.OrderedDict(
+        [
+            ("str_index", ["a", "b"]),
+            ("str_column", ["hello", "world"]),
+            ("int_column", [42, 8]),
+            ("nullable_int_column", pandas.Series([42, None], dtype="Int64")),
+            ("uint_column", pandas.Series([7, 13], dtype="uint8")),
+            ("bool_column", [True, False]),
+            ("boolean_column", pandas.Series([True, None], dtype="boolean")),
+            (
+                "datetime_column",
+                [
+                    datetime.datetime(1999, 12, 31, 23, 59, 59, 999999),
+                    datetime.datetime(2000, 1, 1, 0, 0, 0),
+                ],
+            ),
+            (
+                "timestamp_column",
+                [
+                    datetime.datetime(
+                        1999, 12, 31, 23, 59, 59, 999999, tzinfo=datetime.timezone.utc
+                    ),
+                    datetime.datetime(
+                        2000, 1, 1, 0, 0, 0, tzinfo=datetime.timezone.utc
+                    ),
+                ],
+            ),
+            # Need to fallback to Arrow to avoid data loss and disambiguate
+            # NUMERIC from BIGNUMERIC. We don't want to pick too small of a
+            # type and lose precision. See:
+            # https://github.com/googleapis/python-bigquery/issues/1650
+            #
+            (
+                "bignumeric_column",
+                [
+                    # Start with a lower precision Decimal to make sure we
+                    # aren't trying to determine the type from just one value.
+                    decimal.Decimal("1.25"),
+                    decimal.Decimal("0.1234567891"),
+                ],
+            ),
+            (
+                "numeric_column",
+                [
+                    # Minimum value greater than 0 that can be handled: 1e-9
+                    # https://cloud.google.com/bigquery/docs/reference/standard-sql/data-types#numeric_types
+                    decimal.Decimal("0.000000001"),
+                    decimal.Decimal("-0.000000001"),
+                ],
+            ),
+        ]
+    )
+    dataframe = pandas.DataFrame(df_data).set_index("str_index", drop=True)
+
+    returned_schema = module_under_test.dataframe_to_bigquery_fields(
+        dataframe, [], index=True
+    )
+
+    expected_schema = (
+        schema.SchemaField("str_index", "STRING", "NULLABLE"),
+        schema.SchemaField("str_column", "STRING", "NULLABLE"),
+        schema.SchemaField("int_column", "INTEGER", "NULLABLE"),
+        schema.SchemaField("nullable_int_column", "INTEGER", "NULLABLE"),
+        schema.SchemaField("uint_column", "INTEGER", "NULLABLE"),
+        schema.SchemaField("bool_column", "BOOLEAN", "NULLABLE"),
+        schema.SchemaField("boolean_column", "BOOLEAN", "NULLABLE"),
+        schema.SchemaField("datetime_column", "DATETIME", "NULLABLE"),
+        schema.SchemaField("timestamp_column", "TIMESTAMP", "NULLABLE"),
+        schema.SchemaField("bignumeric_column", "BIGNUMERIC", "NULLABLE"),
+        schema.SchemaField("numeric_column", "NUMERIC", "NULLABLE"),
+    )
+    assert returned_schema == expected_schema
+
+
+def test_dataframe_to_bigquery_fields_w_multiindex(module_under_test):
+    df_data = collections.OrderedDict(
+        [
+            ("str_index", ["a", "a"]),
+            ("int_index", [0, 0]),
+            (
+                "dt_index",
+                [
+                    datetime.datetime(1999, 12, 31, 23, 59, 59, 999999),
+                    datetime.datetime(2000, 1, 1, 0, 0, 0),
+                ],
+            ),
+            ("str_column", ["hello", "world"]),
+            ("int_column", [42, 8]),
+            ("bool_column", [True, False]),
+        ]
+    )
+    dataframe = pandas.DataFrame(df_data).set_index(
+        ["str_index", "int_index", "dt_index"],
+        drop=True,
+    )
+
+    returned_schema = module_under_test.dataframe_to_bigquery_fields(
+        dataframe, [], index=True
+    )
+
+    expected_schema = (
+        schema.SchemaField("str_index", "STRING", "NULLABLE"),
+        schema.SchemaField("int_index", "INTEGER", "NULLABLE"),
+        schema.SchemaField("dt_index", "DATETIME", "NULLABLE"),
+        schema.SchemaField("str_column", "STRING", "NULLABLE"),
+        schema.SchemaField("int_column", "INTEGER", "NULLABLE"),
+        schema.SchemaField("bool_column", "BOOLEAN", "NULLABLE"),
+    )
+    assert returned_schema == expected_schema
+
+
+def test_dataframe_to_bigquery_fields_w_bq_schema(module_under_test):
+    df_data = collections.OrderedDict(
+        [
+            ("str_column", ["hello", "world"]),
+            ("int_column", [42, 8]),
+            ("bool_column", [True, False]),
+        ]
+    )
+    dataframe = pandas.DataFrame(df_data)
+
+    dict_schema = [
+        {"name": "str_column", "type": "STRING", "mode": "NULLABLE"},
+        {"name": "bool_column", "type": "BOOL", "mode": "REQUIRED"},
+    ]
+
+    returned_schema = module_under_test.dataframe_to_bigquery_fields(
+        dataframe, dict_schema
+    )
+
+    expected_schema = (
+        schema.SchemaField("str_column", "STRING", "NULLABLE"),
+        schema.SchemaField("int_column", "INTEGER", "NULLABLE"),
+        schema.SchemaField("bool_column", "BOOL", "REQUIRED"),
+    )
+    assert returned_schema == expected_schema
+
+
+def test_dataframe_to_bigquery_fields_fallback_needed_w_pyarrow(module_under_test):
+    dataframe = pandas.DataFrame(
+        data=[
+            {"id": 10, "status": "FOO", "created_at": datetime.date(2019, 5, 10)},
+            {"id": 20, "status": "BAR", "created_at": datetime.date(2018, 9, 12)},
+        ]
+    )
+
+    detected_schema = module_under_test.dataframe_to_bigquery_fields(
+        dataframe, override_bigquery_fields=[]
+    )
+    expected_schema = (
+        schema.SchemaField("id", "INTEGER", mode="NULLABLE"),
+        schema.SchemaField("status", "STRING", mode="NULLABLE"),
+        schema.SchemaField("created_at", "DATE", mode="NULLABLE"),
+    )
+    by_name = operator.attrgetter("name")
+    assert sorted(detected_schema, key=by_name) == sorted(expected_schema, key=by_name)
+
+
+def test_dataframe_to_bigquery_fields_w_extra_fields(module_under_test):
+    dataframe = pandas.DataFrame({"in_df": [1, 2, 3]})
+    bq_schema = (
+        schema.SchemaField("in_df", "INTEGER"),
+        schema.SchemaField("not_in_df", "STRING"),
+        schema.SchemaField("also_not_in_df", "INTEGER"),
+    )
+
+    with pytest.warns(UserWarning) as record:
+        returned_schema = module_under_test.dataframe_to_bigquery_fields(
+            dataframe, override_bigquery_fields=bq_schema
+        )
+
+    assert len(record) == 1
+    message = str(record[0].message)
+    assert (
+        "Provided BigQuery fields contain field(s) not present in DataFrame" in message
+    )
+    # Note: The field names are sorted in the warning message.
+    assert "['also_not_in_df', 'not_in_df']" in message
+
+    expected_schema = (
+        schema.SchemaField("in_df", "INTEGER"),
+        # Note: The fields are sorted by name as they are added from the set of
+        # unused fields.
+        schema.SchemaField("also_not_in_df", "INTEGER"),
+        schema.SchemaField("not_in_df", "STRING"),
+    )
+    assert returned_schema == expected_schema
+
+
+def test_dataframe_to_bigquery_fields_geography(module_under_test):
+    geopandas = pytest.importorskip("geopandas")
+    from shapely import wkt
+
+    df = geopandas.GeoDataFrame(
+        pandas.DataFrame(
+            dict(
+                name=["foo", "bar"],
+                geo1=[None, None],
+                geo2=[None, wkt.loads("Point(1 1)")],
+            )
+        ),
+        geometry="geo1",
+    )
+    bq_schema = module_under_test.dataframe_to_bigquery_fields(df, [])
+    assert bq_schema == (
+        schema.SchemaField("name", "STRING"),
+        schema.SchemaField("geo1", "GEOGRAPHY"),
+        schema.SchemaField("geo2", "GEOGRAPHY"),
+    )
diff --git a/packages/pandas-gbq/tests/unit/schema/test_pyarrow_to_bigquery.py b/packages/pandas-gbq/tests/unit/schema/test_pyarrow_to_bigquery.py
new file mode 100644
index 000000000000..dc5504f99e12
--- /dev/null
+++ b/packages/pandas-gbq/tests/unit/schema/test_pyarrow_to_bigquery.py
@@ -0,0 +1,55 @@
+# Copyright (c) 2024 pandas-gbq Authors All rights reserved.
+# Use of this source code is governed by a BSD-style
+# license that can be found in the LICENSE file.
+
+from google.cloud import bigquery
+import pyarrow
+import pytest
+
+from pandas_gbq.schema import pyarrow_to_bigquery
+
+
+@pytest.mark.parametrize(
+    (
+        "pyarrow_type",
+        "bigquery_type",
+    ),
+    (
+        # All integer types should map to BigQuery INT64 (or INTEGER since
+        # SchemaField uses the legacy SQL names). See:
+        # https://github.com/googleapis/python-bigquery-pandas/issues/616
+        (pyarrow.int8(), "INTEGER"),
+        (pyarrow.int16(), "INTEGER"),
+        (pyarrow.int32(), "INTEGER"),
+        (pyarrow.int64(), "INTEGER"),
+        (pyarrow.uint8(), "INTEGER"),
+        (pyarrow.uint16(), "INTEGER"),
+        (pyarrow.uint32(), "INTEGER"),
+        (pyarrow.uint64(), "INTEGER"),
+        # If there is no associated timezone, assume a naive (timezone-less)
+        # DATETIME. See:
+        # https://github.com/googleapis/python-bigquery-pandas/issues/450
+        (pyarrow.timestamp("ns"), "DATETIME"),
+        (pyarrow.timestamp("ns", tz="UTC"), "TIMESTAMP"),
+    ),
+)
+def test_arrow_type_to_bigquery_field_scalar_types(pyarrow_type, bigquery_type):
+    field: bigquery.SchemaField = pyarrow_to_bigquery.arrow_type_to_bigquery_field(
+        "test_name", pyarrow_type
+    )
+    assert field.name == "test_name"
+    assert field.field_type == bigquery_type
+
+
+def test_arrow_type_to_bigquery_field_unknown():
+    assert pyarrow_to_bigquery.arrow_type_to_bigquery_field(
+        "test_name", pyarrow.null(), default_type="DEFAULT_TYPE"
+    ) == bigquery.SchemaField("test_name", "DEFAULT_TYPE")
+
+
+def test_arrow_type_to_bigquery_field_list_of_unknown():
+    assert pyarrow_to_bigquery.arrow_type_to_bigquery_field(
+        "test_name",
+        pyarrow.list_(pyarrow.null()),
+        default_type="DEFAULT_TYPE",
+    ) == bigquery.SchemaField("test_name", "DEFAULT_TYPE", mode="REPEATED")
diff --git a/packages/pandas-gbq/tests/unit/test_auth.py b/packages/pandas-gbq/tests/unit/test_auth.py
new file mode 100644
index 000000000000..d44c6380b575
--- /dev/null
+++ b/packages/pandas-gbq/tests/unit/test_auth.py
@@ -0,0 +1,67 @@
+# Copyright (c) 2017 pandas-gbq Authors All rights reserved.
+# Use of this source code is governed by a BSD-style
+# license that can be found in the LICENSE file.
+
+# -*- coding: utf-8 -*-
+
+import json
+from unittest import mock
+
+import pytest
+
+from pandas_gbq import auth
+
+
+def test_get_credentials_private_key_raises_notimplementederror(monkeypatch):
+    private_key = json.dumps(
+        {
+            "private_key": "some_key",
+            "client_email": "service-account@example.com",
+            "project_id": "private-key-project",
+        }
+    )
+    with pytest.raises(NotImplementedError, match="private_key"):
+        auth.get_credentials(private_key=private_key)
+
+
+def test_get_credentials_default_credentials(monkeypatch):
+    import google.auth
+    import google.auth.credentials
+    import google.cloud.bigquery
+    import pydata_google_auth
+
+    mock_user_credentials = mock.create_autospec(google.auth.credentials.Credentials)
+
+    def mock_default_credentials(scopes, **kwargs):
+        return (mock_user_credentials, "test-project")
+
+    monkeypatch.setattr(pydata_google_auth, "default", mock_default_credentials)
+
+    credentials, project = auth.get_credentials()
+    assert project == "test-project"
+    assert credentials is not None
+
+
+def test_get_credentials_load_user_no_default(monkeypatch):
+    import google.auth
+    import google.auth.credentials
+    import pydata_google_auth
+    import pydata_google_auth.cache
+
+    mock_user_credentials = mock.create_autospec(google.auth.credentials.Credentials)
+
+    def mock_default_credentials(scopes, **kwargs):
+        return (mock_user_credentials, None)
+
+    monkeypatch.setattr(pydata_google_auth, "default", mock_default_credentials)
+
+    credentials, project = auth.get_credentials()
+    assert project is None
+    assert credentials is mock_user_credentials
+
+
+def test_get_credentials_cache_w_reauth():
+    import pydata_google_auth.cache
+
+    cache = auth.get_credentials_cache(True)
+    assert isinstance(cache, pydata_google_auth.cache.WriteOnlyCredentialsCache)
diff --git a/packages/pandas-gbq/tests/unit/test_context.py b/packages/pandas-gbq/tests/unit/test_context.py
new file mode 100644
index 000000000000..451153022dba
--- /dev/null
+++ b/packages/pandas-gbq/tests/unit/test_context.py
@@ -0,0 +1,114 @@
+# Copyright (c) 2017 pandas-gbq Authors All rights reserved.
+# Use of this source code is governed by a BSD-style
+# license that can be found in the LICENSE file.
+
+# -*- coding: utf-8 -*-
+
+from unittest import mock
+
+import google.cloud.bigquery
+import google.cloud.bigquery.table
+import packaging.version
+import pytest
+
+
+@pytest.fixture(autouse=True)
+def default_bigquery_client(mock_bigquery_client):
+    mock_query = mock.create_autospec(google.cloud.bigquery.QueryJob)
+    mock_query.job_id = "some-random-id"
+    mock_query.state = "DONE"
+    mock_rows = mock.create_autospec(google.cloud.bigquery.table.RowIterator)
+    mock_rows.total_rows = 1
+    mock_rows.__iter__.return_value = [(1,)]
+    mock_query.result.return_value = mock_rows
+    mock_bigquery_client.list_rows.return_value = mock_rows
+    mock_bigquery_client.query.return_value = mock_query
+    return mock_bigquery_client
+
+
+@pytest.fixture(autouse=True)
+def mock_get_credentials(monkeypatch):
+    import google.auth.credentials
+
+    from pandas_gbq import auth
+
+    mock_credentials = mock.MagicMock(google.auth.credentials.Credentials)
+    mock_get_credentials = mock.Mock()
+    mock_get_credentials.return_value = (mock_credentials, "my-project")
+
+    monkeypatch.setattr(auth, "get_credentials", mock_get_credentials)
+    return mock_get_credentials
+
+
+def test_read_gbq_should_save_credentials(mock_get_credentials):
+    import pandas_gbq
+
+    assert pandas_gbq.context.credentials is None
+    assert pandas_gbq.context.project is None
+
+    pandas_gbq.read_gbq("SELECT 1", dialect="standard")
+
+    assert mock_get_credentials.call_count == 1
+    mock_get_credentials.reset_mock()
+    assert pandas_gbq.context.credentials is not None
+    assert pandas_gbq.context.project is not None
+
+    pandas_gbq.read_gbq("SELECT 1", dialect="standard")
+    mock_get_credentials.assert_not_called()
+
+
+def test_read_gbq_should_use_dialect_with_query(monkeypatch, mock_bigquery_client):
+    import pandas_gbq
+    import pandas_gbq.features
+
+    monkeypatch.setattr(
+        pandas_gbq.features.FEATURES,
+        "_bigquery_installed_version",
+        packaging.version.parse(pandas_gbq.features.BIGQUERY_MINIMUM_VERSION),
+    )
+
+    assert pandas_gbq.context.dialect is None
+    pandas_gbq.context.dialect = "legacy"
+    pandas_gbq.read_gbq("SELECT 1")
+
+    _, kwargs = mock_bigquery_client.query.call_args
+    assert kwargs["job_config"].use_legacy_sql
+
+    pandas_gbq.context.dialect = "standard"
+    pandas_gbq.read_gbq("SELECT 1")
+
+    _, kwargs = mock_bigquery_client.query.call_args
+    assert not kwargs["job_config"].use_legacy_sql
+    pandas_gbq.context.dialect = None  # Reset the global state.
+
+
+def test_read_gbq_should_use_dialect_with_query_and_wait(
+    monkeypatch, mock_bigquery_client
+):
+    if not hasattr(mock_bigquery_client, "query_and_wait"):
+        pytest.skip(
+            f"google-cloud-bigquery {google.cloud.bigquery.__version__} does not have query_and_wait"
+        )
+
+    import pandas_gbq
+    import pandas_gbq.features
+
+    monkeypatch.setattr(
+        pandas_gbq.features.FEATURES,
+        "_bigquery_installed_version",
+        packaging.version.parse(pandas_gbq.features.BIGQUERY_QUERY_AND_WAIT_VERSION),
+    )
+
+    assert pandas_gbq.context.dialect is None
+    pandas_gbq.context.dialect = "legacy"
+    pandas_gbq.read_gbq("SELECT 1")
+
+    _, kwargs = mock_bigquery_client.query_and_wait.call_args
+    assert kwargs["job_config"].use_legacy_sql
+
+    pandas_gbq.context.dialect = "standard"
+    pandas_gbq.read_gbq("SELECT 1")
+
+    _, kwargs = mock_bigquery_client.query_and_wait.call_args
+    assert not kwargs["job_config"].use_legacy_sql
+    pandas_gbq.context.dialect = None  # Reset the global state.
diff --git a/packages/pandas-gbq/tests/unit/test_core_sample.py b/packages/pandas-gbq/tests/unit/test_core_sample.py
new file mode 100644
index 000000000000..5e5a15e77382
--- /dev/null
+++ b/packages/pandas-gbq/tests/unit/test_core_sample.py
@@ -0,0 +1,348 @@
+# Copyright (c) 2025 pandas-gbq Authors All rights reserved.
+# Use of this source code is governed by a BSD-style
+# license that can be found in the LICENSE file.
+
+from typing import Sequence
+from unittest import mock
+
+import google.cloud.bigquery
+import pytest
+
+import pandas_gbq.constants
+import pandas_gbq.core.sample
+
+
+@pytest.mark.parametrize(
+    "schema, expected_size",
+    [
+        pytest.param(
+            [
+                google.cloud.bigquery.SchemaField("id", "INT64"),  # 8
+                google.cloud.bigquery.SchemaField("is_valid", "BOOL"),  # 1
+                google.cloud.bigquery.SchemaField("price", "NUMERIC"),  # 16
+                google.cloud.bigquery.SchemaField("big_value", "BIGNUMERIC"),  # 32
+            ],
+            8 + 1 + 16 + 32,  # 57
+            id="Fixed_Size_Types",
+        ),
+        pytest.param(
+            [
+                google.cloud.bigquery.SchemaField(
+                    "coords",
+                    "RECORD",
+                    fields=[
+                        google.cloud.bigquery.SchemaField("lat", "FLOAT64"),  # 8
+                        google.cloud.bigquery.SchemaField("lon", "FLOAT64"),  # 8
+                    ],
+                ),
+            ],
+            16,  # 8 + 8
+            id="Simple_Struct",
+        ),
+        pytest.param(
+            [
+                google.cloud.bigquery.SchemaField(
+                    "history", "TIMESTAMP", mode="REPEATED"
+                ),  # 5 * 8
+            ],
+            pandas_gbq.core.sample._ARRAY_LENGTH_ESTIMATE * 8,  # 40
+            id="Simple_Array",
+        ),
+        pytest.param(
+            [
+                google.cloud.bigquery.SchemaField(
+                    "addresses",
+                    "RECORD",
+                    mode="REPEATED",
+                    fields=[
+                        google.cloud.bigquery.SchemaField("street", "STRING"),  # 1KIB
+                        google.cloud.bigquery.SchemaField("zip", "INT64"),  # 8
+                    ],
+                ),
+            ],
+            pandas_gbq.core.sample._ARRAY_LENGTH_ESTIMATE
+            * (pandas_gbq.constants.BYTES_IN_KIB + 8),
+            id="Repeated_Struct",
+        ),
+        pytest.param(
+            [
+                google.cloud.bigquery.SchemaField(
+                    "empty_struct", "RECORD", fields=[]
+                ),  # 0
+                google.cloud.bigquery.SchemaField("simple_int", "INT64"),  # 8
+            ],
+            8,  # 0 + 8
+            id="empty-struct",
+        ),
+        pytest.param(
+            [
+                google.cloud.bigquery.SchemaField("bytes", "BYTES"),
+            ]
+            * 9_999,
+            pandas_gbq.core.sample._MAX_ROW_BYTES,
+            id="many-bytes",
+        ),
+        # Case 8: Complex Mix (Combining multiple cases)
+        pytest.param(
+            [
+                google.cloud.bigquery.SchemaField("key", "INT64"),  # 8
+                google.cloud.bigquery.SchemaField("notes", "STRING"),  # 1KIB
+                google.cloud.bigquery.SchemaField(
+                    "history", "TIMESTAMP", mode="REPEATED"
+                ),  # 40
+                google.cloud.bigquery.SchemaField(
+                    "details",
+                    "RECORD",
+                    fields=[
+                        google.cloud.bigquery.SchemaField("d1", "NUMERIC"),  # 16
+                        google.cloud.bigquery.SchemaField("d2", "BYTES"),  # 1MB
+                    ],
+                ),
+            ],
+            8
+            + pandas_gbq.constants.BYTES_IN_KIB
+            + 40
+            + (16 + pandas_gbq.constants.BYTES_IN_MIB),
+            id="Complex_Mix",
+        ),
+    ],
+)
+def test_estimate_row_size_parametrized(
+    schema: Sequence[google.cloud.bigquery.SchemaField], expected_size: int
+):
+    actual_size = pandas_gbq.core.sample._estimate_row_bytes(schema)
+    assert actual_size == expected_size
+
+
+def test_calculate_target_bytes_with_target_mb():
+    target_mb = 200
+    expected_bytes = target_mb * pandas_gbq.constants.BYTES_IN_MIB
+    actual_bytes = pandas_gbq.core.sample._calculate_target_bytes(target_mb)
+    assert actual_bytes == expected_bytes
+
+
+@mock.patch("psutil.virtual_memory")
+def test_calculate_target_bytes_with_available_memory(mock_virtual_memory):
+    # Mock psutil.virtual_memory to return a mock object with an 'available' attribute.
+    available_memory = 2 * pandas_gbq.constants.BYTES_IN_GIB  # 2 GB
+    mock_virtual_memory.return_value = mock.Mock(available=available_memory)
+
+    # Expected bytes is available memory / 4, as it falls between _MAX_ROW_BYTES and _MAX_AUTO_TARGET_BYTES
+    expected_bytes = available_memory // 4
+    actual_bytes = pandas_gbq.core.sample._calculate_target_bytes(None)
+    assert actual_bytes == expected_bytes
+
+
+@mock.patch("psutil.virtual_memory")
+def test_calculate_target_bytes_low_memory_uses_max_row_bytes(mock_virtual_memory):
+    # Mock psutil.virtual_memory to return a mock object with an 'available' attribute.
+    # Set available memory to a low value.
+    available_memory = 100  # 100 bytes
+    mock_virtual_memory.return_value = mock.Mock(available=available_memory)
+
+    # Expected bytes should be _MAX_ROW_BYTES because available // 4 is less.
+    expected_bytes = pandas_gbq.core.sample._MAX_ROW_BYTES
+    actual_bytes = pandas_gbq.core.sample._calculate_target_bytes(None)
+    assert actual_bytes == expected_bytes
+
+
+@mock.patch("psutil.virtual_memory")
+def test_calculate_target_bytes_caps_at_max_auto_target_bytes(mock_virtual_memory):
+    # Mock psutil.virtual_memory to return a mock object with an 'available' attribute.
+    # Set available memory to a high value (e.g., 8 GB) so that available // 4 > _MAX_AUTO_TARGET_BYTES.
+    available_memory = 8 * pandas_gbq.constants.BYTES_IN_GIB  # 8 GB
+    mock_virtual_memory.return_value = mock.Mock(available=available_memory)
+
+    # Expected bytes should be _MAX_AUTO_TARGET_BYTES (1 GiB) because available // 4 (2 GiB) is capped.
+    expected_bytes = pandas_gbq.core.sample._MAX_AUTO_TARGET_BYTES
+    actual_bytes = pandas_gbq.core.sample._calculate_target_bytes(None)
+    assert actual_bytes == expected_bytes
+
+
+@pytest.mark.parametrize(
+    "target_bytes, table_bytes, table_rows, fields, expected_limit",
+    [
+        # With table_bytes and table_rows, should use proportion
+        pytest.param(
+            1000, 10000, 100, [], 10, id="with-stats-simple"
+        ),  # 100 * (1000/10000)
+        pytest.param(1, 10000, 100, [], 1, id="with-stats-min-1"),  # min is 1
+        # Without stats, should estimate from schema
+        pytest.param(
+            1000,
+            None,
+            None,
+            [google.cloud.bigquery.SchemaField("col1", "INT64")],  # 8 bytes
+            125,  # 1000 // 8
+            id="no-stats-simple",
+        ),
+        pytest.param(
+            10,
+            None,
+            None,
+            [google.cloud.bigquery.SchemaField("col1", "NUMERIC")],  # 16 bytes
+            1,  # max(1, 10 // 16)
+            id="no-stats-min-1",
+        ),
+        # Edge case: row_bytes_estimate is 0
+        pytest.param(
+            1000,
+            None,
+            None,
+            [],
+            1000,
+            id="no-stats-zero-row-size",  # empty schema -> 0 bytes
+        ),
+    ],
+)
+def test_estimate_limit(target_bytes, table_bytes, table_rows, fields, expected_limit):
+    limit = pandas_gbq.core.sample._estimate_limit(
+        target_bytes=target_bytes,
+        table_bytes=table_bytes,
+        table_rows=table_rows,
+        fields=fields,
+    )
+    assert limit == expected_limit
+
+
+@mock.patch("pandas_gbq.core.read.download_results")
+def test_sample_with_tablesample(mock_download_results, mock_bigquery_client):
+    mock_table = mock.Mock(spec=google.cloud.bigquery.Table)
+    mock_table.project = "test-project"
+    mock_table.dataset_id = "test_dataset"
+    mock_table.table_id = "test_table"
+
+    proportion = 0.1
+    target_row_count = 100
+
+    pandas_gbq.core.sample._sample_with_tablesample(
+        mock_table,
+        bqclient=mock_bigquery_client,
+        proportion=proportion,
+        target_row_count=target_row_count,
+    )
+
+    mock_bigquery_client.query_and_wait.assert_called_once()
+    query = mock_bigquery_client.query_and_wait.call_args[0][0]
+    assert "TABLESAMPLE SYSTEM (10.0 PERCENT)" in query
+    assert "LIMIT 100" in query
+    assert (
+        f"FROM `{mock_table.project}.{mock_table.dataset_id}.{mock_table.table_id}`"
+        in query
+    )
+
+    mock_download_results.assert_called_once()
+
+
+@mock.patch("pandas_gbq.core.read.download_results")
+def test_sample_with_limit(mock_download_results, mock_bigquery_client):
+    mock_table = mock.Mock(spec=google.cloud.bigquery.Table)
+    mock_table.project = "test-project"
+    mock_table.dataset_id = "test_dataset"
+    mock_table.table_id = "test_table"
+
+    target_row_count = 200
+
+    pandas_gbq.core.sample._sample_with_limit(
+        mock_table,
+        bqclient=mock_bigquery_client,
+        target_row_count=target_row_count,
+    )
+
+    mock_bigquery_client.query_and_wait.assert_called_once()
+    query = mock_bigquery_client.query_and_wait.call_args[0][0]
+    assert "TABLESAMPLE" not in query
+    assert "LIMIT 200" in query
+    assert (
+        f"FROM `{mock_table.project}.{mock_table.dataset_id}.{mock_table.table_id}`"
+        in query
+    )
+
+    mock_download_results.assert_called_once()
+
+
+@pytest.fixture
+def mock_gbq_connector(mock_bigquery_client):
+    with mock.patch("pandas_gbq.gbq_connector.GbqConnector") as mock_connector_class:
+        mock_connector = mock_connector_class.return_value
+        mock_connector.get_client.return_value = mock_bigquery_client
+        mock_connector.credentials = mock.Mock()
+        yield mock_connector
+
+
+@mock.patch("pandas_gbq.core.read.download_results")
+def test_sample_small_table_downloads_all(
+    mock_download_results, mock_gbq_connector, mock_bigquery_client
+):
+    mock_table = mock.Mock(spec=google.cloud.bigquery.Table)
+    type(mock_table).table_type = mock.PropertyMock(return_value="TABLE")
+    type(mock_table).num_bytes = mock.PropertyMock(return_value=1000)
+    type(mock_table).num_rows = mock.PropertyMock(return_value=10)
+    type(mock_table).schema = mock.PropertyMock(return_value=[])
+    mock_bigquery_client.get_table.return_value = mock_table
+
+    with mock.patch(
+        "pandas_gbq.core.sample._calculate_target_bytes", return_value=2000
+    ):
+        pandas_gbq.core.sample.sample("my-project.my_dataset.my_table")
+
+    mock_bigquery_client.list_rows.assert_called_once_with(mock_table)
+    mock_download_results.assert_called_once()
+    # Check that we didn't try to run a query for sampling
+    mock_bigquery_client.query_and_wait.assert_not_called()
+
+
+@mock.patch("pandas_gbq.core.sample._sample_with_tablesample")
+def test_sample_uses_tablesample(
+    mock_sample_with_tablesample, mock_gbq_connector, mock_bigquery_client
+):
+    mock_table = mock.Mock(spec=google.cloud.bigquery.Table)
+    type(mock_table).table_type = mock.PropertyMock(return_value="TABLE")
+    type(mock_table).num_bytes = mock.PropertyMock(return_value=1_000_000_000_000)
+    type(mock_table).num_rows = mock.PropertyMock(return_value=1_000)
+    type(mock_table).schema = mock.PropertyMock(
+        return_value=[google.cloud.bigquery.SchemaField("col1", "INT64")]
+    )
+    mock_bigquery_client.get_table.return_value = mock_table
+
+    pandas_gbq.core.sample.sample("my-project.my_dataset.my_table", target_mb=1)
+
+    mock_sample_with_tablesample.assert_called_once()
+
+
+@mock.patch("pandas_gbq.core.sample._sample_with_limit")
+def test_sample_uses_limit_fallback(
+    mock_sample_with_limit, mock_gbq_connector, mock_bigquery_client
+):
+    mock_table = mock.Mock(spec=google.cloud.bigquery.Table)
+    mock_table.num_bytes = 10000
+    mock_table.num_rows = 100
+    mock_table.table_type = "VIEW"  # Not eligible for TABLESAMPLE
+    mock_table.schema = [google.cloud.bigquery.SchemaField("col1", "INT64")]
+    mock_bigquery_client.get_table.return_value = mock_table
+
+    with mock.patch(
+        "pandas_gbq.core.sample._calculate_target_bytes", return_value=1000
+    ):
+        pandas_gbq.core.sample.sample("my-project.my_dataset.my_table")
+
+    mock_sample_with_limit.assert_called_once()
+
+
+@mock.patch("pandas_gbq.core.sample._sample_with_limit")
+def test_sample_uses_limit_fallback_no_bytes(
+    mock_sample_with_limit, mock_gbq_connector, mock_bigquery_client
+):
+    mock_table = mock.Mock(spec=google.cloud.bigquery.Table)
+    mock_table.num_bytes = None  # num_bytes can be None
+    mock_table.num_rows = 100
+    mock_table.table_type = "TABLE"
+    mock_table.schema = [google.cloud.bigquery.SchemaField("col1", "INT64")]
+    mock_bigquery_client.get_table.return_value = mock_table
+
+    with mock.patch(
+        "pandas_gbq.core.sample._calculate_target_bytes", return_value=1000
+    ):
+        pandas_gbq.core.sample.sample("my-project.my_dataset.my_table")
+
+    mock_sample_with_limit.assert_called_once()
diff --git a/packages/pandas-gbq/tests/unit/test_features.py b/packages/pandas-gbq/tests/unit/test_features.py
new file mode 100644
index 000000000000..947cb8ae50e7
--- /dev/null
+++ b/packages/pandas-gbq/tests/unit/test_features.py
@@ -0,0 +1,48 @@
+# Copyright (c) 2017 pandas-gbq Authors All rights reserved.
+# Use of this source code is governed by a BSD-style
+# license that can be found in the LICENSE file.
+
+import pytest
+
+from pandas_gbq.features import FEATURES
+
+
+@pytest.fixture(autouse=True)
+def fresh_bigquery_version(monkeypatch):
+    monkeypatch.setattr(FEATURES, "_bigquery_installed_version", None)
+    monkeypatch.setattr(FEATURES, "_pandas_installed_version", None)
+
+
+@pytest.mark.parametrize(
+    ["bigquery_version", "expected"],
+    [
+        ("1.99.100", False),
+        ("2.99.999", False),
+        ("3.13.11", False),
+        ("3.14.0", True),
+        ("4.999.999", True),
+    ],
+)
+def test_bigquery_has_query_and_wait(monkeypatch, bigquery_version, expected):
+    import google.cloud.bigquery
+
+    monkeypatch.setattr(google.cloud.bigquery, "__version__", bigquery_version)
+    assert FEATURES.bigquery_has_query_and_wait == expected
+
+
+@pytest.mark.parametrize(
+    ["pandas_version", "expected"],
+    [
+        ("0.14.7", False),
+        ("0.22.1", False),
+        ("0.23.0", True),
+        ("0.23.1", True),
+        ("1.0.0", True),
+        ("2.1.3", True),
+    ],
+)
+def test_pandas_has_deprecated_verbose(monkeypatch, pandas_version, expected):
+    import pandas
+
+    monkeypatch.setattr(pandas, "__version__", pandas_version)
+    assert FEATURES.pandas_has_deprecated_verbose == expected
diff --git a/packages/pandas-gbq/tests/unit/test_gbq.py b/packages/pandas-gbq/tests/unit/test_gbq.py
new file mode 100644
index 000000000000..6eafe9e2ef92
--- /dev/null
+++ b/packages/pandas-gbq/tests/unit/test_gbq.py
@@ -0,0 +1,940 @@
+# Copyright (c) 2017 pandas-gbq Authors All rights reserved.
+# Use of this source code is governed by a BSD-style
+# license that can be found in the LICENSE file.
+
+# -*- coding: utf-8 -*-
+
+import copy
+import datetime
+import re
+from unittest import mock
+import warnings
+
+import google.api_core.exceptions
+import google.cloud.bigquery
+import google.cloud.bigquery.table
+import numpy
+import packaging.version
+import pandas
+from pandas import DataFrame
+import pytest
+
+from pandas_gbq import gbq
+import pandas_gbq.constants
+import pandas_gbq.core.read
+import pandas_gbq.exceptions
+import pandas_gbq.features
+from pandas_gbq.features import FEATURES
+
+pytestmark = pytest.mark.filterwarnings("ignore:credentials from Google Cloud SDK")
+
+
+def _make_connector(project_id="some-project", **kwargs):
+    return gbq.GbqConnector(project_id, **kwargs)
+
+
+def mock_get_credentials_no_project(*args, **kwargs):
+    import google.auth.credentials
+
+    mock_credentials = mock.create_autospec(google.auth.credentials.Credentials)
+    return mock_credentials, None
+
+
+@pytest.fixture
+def mock_query_job():
+    mock_query = mock.create_autospec(google.cloud.bigquery.QueryJob)
+    mock_query.job_id = "some-random-id"
+    mock_query.state = "DONE"
+    return mock_query
+
+
+@pytest.fixture
+def mock_row_iterator(mock_bigquery_client):
+    mock_rows = mock.create_autospec(google.cloud.bigquery.table.RowIterator)
+    mock_rows.total_rows = 1
+    mock_rows.__iter__.return_value = [(1,)]
+
+    # Mock out SELECT 1 query results.
+    def generate_schema():
+        if mock_bigquery_client.query.call_args:
+            query = mock_bigquery_client.query.call_args[0][0]
+        elif (
+            hasattr(mock_bigquery_client, "query_and_wait")
+            and mock_bigquery_client.query_and_wait.call_args
+        ):
+            query = mock_bigquery_client.query_and_wait.call_args[0][0]
+        else:
+            query = ""
+        if query == "SELECT 1 AS int_col":
+            return [google.cloud.bigquery.SchemaField("int_col", "INTEGER")]
+        else:
+            return [google.cloud.bigquery.SchemaField("_f0", "INTEGER")]
+
+    type(mock_rows).schema = mock.PropertyMock(side_effect=generate_schema)
+    return mock_rows
+
+
+@pytest.fixture(autouse=True)
+def default_bigquery_client(mock_bigquery_client, mock_query_job, mock_row_iterator):
+    mock_query_job.result.return_value = mock_row_iterator
+    mock_bigquery_client.list_rows.return_value = mock_row_iterator
+    mock_bigquery_client.query.return_value = mock_query_job
+
+    if hasattr(mock_bigquery_client, "query_and_wait"):
+        mock_bigquery_client.query_and_wait.return_value = mock_row_iterator
+
+    # Mock out get_table.
+    def get_table(table_ref_or_id, **kwargs):
+        return google.cloud.bigquery.Table(table_ref_or_id)
+
+    mock_bigquery_client.get_table.side_effect = get_table
+
+    return mock_bigquery_client
+
+
+@pytest.mark.parametrize(
+    ("type_", "expected"),
+    [
+        ("SOME_NEW_UNKNOWN_TYPE", None),
+        ("INTEGER", "Int64"),
+        ("FLOAT", numpy.dtype(float)),
+        # TIMESTAMP/DATETIME might require object dtype for out-of-bounds
+        # values.
+        ("TIMESTAMP", None),
+        ("DATETIME", None),
+    ],
+)
+def test__bqschema_to_nullsafe_dtypes(type_, expected):
+    result = pandas_gbq.core.read._bqschema_to_nullsafe_dtypes(
+        [dict(name="x", type=type_, mode="NULLABLE")]
+    )
+    if not expected:
+        assert result == {}
+    else:
+        assert result == {"x": expected}
+
+
+@pytest.mark.parametrize(
+    ["query_or_table", "expected"],
+    [
+        ("SELECT 1", True),
+        ("SELECT\n1", True),
+        ("SELECT\t1", True),
+        ("dataset.table", False),
+        (" dataset.table ", False),
+        ("\r\ndataset.table\r\n", False),
+        ("project-id.dataset.table", False),
+        (" project-id.dataset.table ", False),
+        ("\r\nproject-id.dataset.table\r\n", False),
+    ],
+)
+def test__is_query(query_or_table, expected):
+    result = gbq._is_query(query_or_table)
+    assert result == expected
+
+
+@pytest.mark.parametrize(
+    ["original", "expected"],
+    [
+        (None, None),
+        ({}, {}),
+        ({"query": {"useQueryCache": False}}, {"query": {"useQueryCache": False}}),
+        ({"jobTimeoutMs": "1234"}, {"jobTimeoutMs": "1234"}),
+        ({"query": {"timeoutMs": "1234"}}, {"query": {}, "jobTimeoutMs": "1234"}),
+    ],
+)
+def test__transform_read_gbq_configuration_makes_copy(original, expected):
+    should_change = original == expected
+    got = gbq._transform_read_gbq_configuration(original)
+    assert got == expected
+    # Catch if we accidentally modified the original.
+    did_change = original == got
+    assert did_change == should_change
+
+
+def test_GbqConnector_download_results_warns_for_large_tables(default_bigquery_client):
+    gbq._test_google_api_imports()
+    connector = _make_connector()
+    rows_iter = mock.create_autospec(
+        google.cloud.bigquery.table.RowIterator, instance=True
+    )
+    table = google.cloud.bigquery.Table.from_api_repr(
+        {
+            "tableReference": {
+                "projectId": "my-proj",
+                "datasetId": "my-dset",
+                "tableId": "my_tbl",
+            },
+            "numBytes": 2 * pandas_gbq.constants.BYTES_IN_GIB,
+        },
+    )
+    rows_iter._table = table
+    default_bigquery_client.get_table.reset_mock(side_effect=True)
+    default_bigquery_client.get_table.return_value = table
+
+    with pytest.warns(
+        pandas_gbq.exceptions.LargeResultsWarning,
+        match=re.escape("Your results are 2.0 GiB. Consider using BigQuery DataFrames"),
+    ):
+        connector._download_results(rows_iter)
+
+
+def test_GbqConnector_download_results_doesnt_warn_for_small_tables(
+    default_bigquery_client,
+):
+    gbq._test_google_api_imports()
+    connector = _make_connector()
+    rows_iter = mock.create_autospec(
+        google.cloud.bigquery.table.RowIterator, instance=True
+    )
+    table = google.cloud.bigquery.Table.from_api_repr(
+        {
+            "tableReference": {
+                "projectId": "my-proj",
+                "datasetId": "my-dset",
+                "tableId": "my_tbl",
+            },
+            "numBytes": 999 * pandas_gbq.constants.BYTES_IN_MIB,
+        },
+    )
+    rows_iter._table = table
+    default_bigquery_client.get_table.reset_mock(side_effect=True)
+    default_bigquery_client.get_table.return_value = table
+
+    with warnings.catch_warnings():
+        warnings.simplefilter(
+            "error", category=pandas_gbq.exceptions.LargeResultsWarning
+        )
+        connector._download_results(rows_iter)
+
+
+def test_GbqConnector_get_client_w_new_bq(mock_bigquery_client):
+    gbq._test_google_api_imports()
+    pytest.importorskip("google.api_core.client_info")
+
+    connector = _make_connector()
+    connector.get_client()
+
+    _, kwargs = mock_bigquery_client.call_args
+    assert kwargs["client_info"].user_agent == "pandas-{}".format(pandas.__version__)
+
+
+def test_GbqConnector_process_http_error_transforms_timeout():
+    original = google.api_core.exceptions.GoogleAPICallError(
+        "Job execution was cancelled: Job timed out after 0s"
+    )
+    with pytest.raises(gbq.QueryTimeout):
+        gbq.GbqConnector.process_http_error(original)
+
+
+def test_to_gbq_should_fail_if_invalid_table_name_passed():
+    with pytest.raises(gbq.NotFoundException):
+        gbq.to_gbq(DataFrame([[1]]), "invalid_table_name", project_id="1234")
+
+
+def test_to_gbq_with_no_project_id_given_should_fail(monkeypatch):
+    import pydata_google_auth
+
+    monkeypatch.setattr(pydata_google_auth, "default", mock_get_credentials_no_project)
+
+    with pytest.raises(ValueError, match="Could not determine project ID"):
+        gbq.to_gbq(DataFrame([[1]]), "dataset.tablename")
+
+
+@pytest.mark.parametrize(
+    ["api_method", "warning_message", "warning_type"],
+    [
+        ("load_parquet", "chunksize is ignored", DeprecationWarning),
+        ("load_csv", "chunksize will be ignored", PendingDeprecationWarning),
+    ],
+)
+def test_to_gbq_with_chunksize_warns_deprecation(
+    api_method, warning_message, warning_type
+):
+    with pytest.warns(warning_type, match=warning_message):
+        gbq.to_gbq(
+            DataFrame([[1]]),
+            "dataset.tablename",
+            project_id="my-project",
+            api_method=api_method,
+            chunksize=100,
+        )
+
+
+@pytest.mark.parametrize(["verbose"], [(True,), (False,)])
+def test_to_gbq_with_verbose_new_pandas_warns_deprecation(monkeypatch, verbose):
+    monkeypatch.setattr(
+        type(FEATURES),
+        "pandas_has_deprecated_verbose",
+        mock.PropertyMock(return_value=True),
+    )
+    with pytest.warns(FutureWarning, match="verbose is deprecated"):
+        gbq.to_gbq(
+            DataFrame([[1]]),
+            "dataset.tablename",
+            project_id="my-project",
+            verbose=verbose,
+        )
+
+
+def test_to_gbq_with_private_key_raises_notimplementederror():
+    with pytest.raises(NotImplementedError, match="private_key"):
+        gbq.to_gbq(
+            DataFrame([[1]]),
+            "dataset.tablename",
+            project_id="my-project",
+            private_key="path/to/key.json",
+        )
+
+
+def test_to_gbq_doesnt_run_query(mock_bigquery_client):
+    gbq.to_gbq(DataFrame([[1]]), "dataset.tablename", project_id="my-project")
+    mock_bigquery_client.query.assert_not_called()
+
+
+def test_to_gbq_w_empty_df(mock_bigquery_client):
+    import google.api_core.exceptions
+
+    mock_bigquery_client.get_table.side_effect = google.api_core.exceptions.NotFound(
+        "my_table"
+    )
+    gbq.to_gbq(DataFrame(), "my_dataset.my_table", project_id="1234")
+    mock_bigquery_client.create_table.assert_called_with(mock.ANY)
+    mock_bigquery_client.load_table_from_dataframe.assert_not_called()
+    mock_bigquery_client.load_table_from_file.assert_not_called()
+
+
+def test_to_gbq_w_default_project(mock_bigquery_client):
+    """If no project is specified, we should be able to use project from
+    default credentials.
+    """
+    import google.api_core.exceptions
+    from google.cloud.bigquery.table import TableReference
+
+    mock_bigquery_client.get_table.side_effect = google.api_core.exceptions.NotFound(
+        "my_table"
+    )
+    gbq.to_gbq(DataFrame(), "my_dataset.my_table")
+
+    mock_bigquery_client.get_table.assert_called_with(
+        TableReference.from_string("default-project.my_dataset.my_table")
+    )
+    mock_bigquery_client.create_table.assert_called_with(mock.ANY)
+    table = mock_bigquery_client.create_table.call_args[0][0]
+    assert table.project == "default-project"
+
+
+def test_to_gbq_w_project_table(mock_bigquery_client):
+    """If a project is included in the table ID, use that instead of the client
+    project. See: https://github.com/pydata/pandas-gbq/issues/321
+    """
+    import google.api_core.exceptions
+    from google.cloud.bigquery.table import TableReference
+
+    mock_bigquery_client.get_table.side_effect = google.api_core.exceptions.NotFound(
+        "my_table"
+    )
+    gbq.to_gbq(
+        DataFrame(),
+        "project_table.my_dataset.my_table",
+        project_id="project_client",
+    )
+
+    mock_bigquery_client.get_table.assert_called_with(
+        TableReference.from_string("project_table.my_dataset.my_table")
+    )
+    mock_bigquery_client.create_table.assert_called_with(mock.ANY)
+    table = mock_bigquery_client.create_table.call_args[0][0]
+    assert table.project == "project_table"
+
+
+def test_to_gbq_create_dataset(mock_bigquery_client):
+    import google.api_core.exceptions
+
+    mock_bigquery_client.get_table.side_effect = google.api_core.exceptions.NotFound(
+        "my_table"
+    )
+    mock_bigquery_client.get_dataset.side_effect = google.api_core.exceptions.NotFound(
+        "my_dataset"
+    )
+    gbq.to_gbq(DataFrame([[1]]), "my_dataset.my_table", project_id="1234")
+    mock_bigquery_client.create_dataset.assert_called_with(mock.ANY)
+
+
+def test_dataset_create_already_exists_translates_exception(mock_bigquery_client):
+    connector = gbq._Dataset("my-project")
+    connector.client = mock_bigquery_client
+    mock_bigquery_client.get_dataset.return_value = object()
+    with pytest.raises(gbq.DatasetCreationError):
+        connector.create("already_exists")
+
+
+def test_dataset_exists_false(mock_bigquery_client):
+    connector = gbq._Dataset("my-project")
+    connector.client = mock_bigquery_client
+    mock_bigquery_client.get_dataset.side_effect = google.api_core.exceptions.NotFound(
+        "nope"
+    )
+    assert not connector.exists("not_exists")
+
+
+def test_dataset_exists_true(mock_bigquery_client):
+    connector = gbq._Dataset("my-project")
+    connector.client = mock_bigquery_client
+    mock_bigquery_client.get_dataset.return_value = object()
+    assert connector.exists("yes_exists")
+
+
+def test_dataset_exists_translates_exception(mock_bigquery_client):
+    connector = gbq._Dataset("my-project")
+    connector.client = mock_bigquery_client
+    mock_bigquery_client.get_dataset.side_effect = (
+        google.api_core.exceptions.InternalServerError("something went wrong")
+    )
+    with pytest.raises(gbq.GenericGBQException):
+        connector.exists("not_gonna_work")
+
+
+def test_table_create_already_exists(mock_bigquery_client):
+    connector = gbq._Table("my-project", "my_dataset")
+    connector.client = mock_bigquery_client
+    mock_bigquery_client.get_table.return_value = object()
+    with pytest.raises(gbq.TableCreationError):
+        connector.create(
+            "already_exists", {"fields": [{"name": "f", "type": "STRING"}]}
+        )
+
+
+def test_table_create_translates_exception(mock_bigquery_client):
+    connector = gbq._Table("my-project", "my_dataset")
+    connector.client = mock_bigquery_client
+    mock_bigquery_client.get_table.side_effect = google.api_core.exceptions.NotFound(
+        "nope"
+    )
+    mock_bigquery_client.create_table.side_effect = (
+        google.api_core.exceptions.InternalServerError("something went wrong")
+    )
+    with pytest.raises(gbq.GenericGBQException):
+        connector.create(
+            "not_gonna_work", {"fields": [{"name": "f", "type": "STRING"}]}
+        )
+
+
+def test_table_delete_notfound_ok(mock_bigquery_client):
+    connector = gbq._Table("my-project", "my_dataset")
+    connector.client = mock_bigquery_client
+    mock_bigquery_client.delete_table.side_effect = google.api_core.exceptions.NotFound(
+        "nope"
+    )
+    connector.delete("not_exists")
+    mock_bigquery_client.delete_table.assert_called_once()
+
+
+def test_table_delete_translates_exception(mock_bigquery_client):
+    connector = gbq._Table("my-project", "my_dataset")
+    connector.client = mock_bigquery_client
+    mock_bigquery_client.delete_table.side_effect = (
+        google.api_core.exceptions.InternalServerError("something went wrong")
+    )
+    with pytest.raises(gbq.GenericGBQException):
+        connector.delete("not_gonna_work")
+
+
+def test_table_exists_false(mock_bigquery_client):
+    connector = gbq._Table("my-project", "my_dataset")
+    connector.client = mock_bigquery_client
+    mock_bigquery_client.get_table.side_effect = google.api_core.exceptions.NotFound(
+        "nope"
+    )
+    assert not connector.exists("not_exists")
+
+
+def test_table_exists_true(mock_bigquery_client):
+    connector = gbq._Table("my-project", "my_dataset")
+    connector.client = mock_bigquery_client
+    mock_bigquery_client.get_table.return_value = object()
+    assert connector.exists("yes_exists")
+
+
+def test_table_exists_translates_exception(mock_bigquery_client):
+    connector = gbq._Table("my-project", "my_dataset")
+    connector.client = mock_bigquery_client
+    mock_bigquery_client.get_table.side_effect = (
+        google.api_core.exceptions.InternalServerError("something went wrong")
+    )
+    with pytest.raises(gbq.GenericGBQException):
+        connector.exists("not_gonna_work")
+
+
+def test_read_gbq_with_no_project_id_given_should_fail(monkeypatch):
+    import pydata_google_auth
+
+    monkeypatch.setattr(pydata_google_auth, "default", mock_get_credentials_no_project)
+
+    with pytest.raises(ValueError, match="Could not determine project ID"):
+        gbq.read_gbq("SELECT 1", dialect="standard")
+
+
+def test_read_gbq_with_inferred_project_id_with_query(
+    monkeypatch, mock_bigquery_client, mock_query_job
+):
+    monkeypatch.setattr(
+        pandas_gbq.features.FEATURES,
+        "_bigquery_installed_version",
+        packaging.version.parse(pandas_gbq.features.BIGQUERY_MINIMUM_VERSION),
+    )
+    type(mock_query_job).cache_hit = mock.PropertyMock(return_value=False)
+    type(mock_query_job).total_bytes_billed = mock.PropertyMock(return_value=10_000_000)
+    type(mock_query_job).total_bytes_processed = mock.PropertyMock(return_value=12345)
+
+    df = gbq.read_gbq("SELECT 1", dialect="standard")
+    assert df is not None
+    mock_bigquery_client.query.assert_called_once()
+
+
+def test_read_gbq_with_inferred_project_id_with_query_and_wait(
+    monkeypatch, mock_bigquery_client
+):
+    if not hasattr(mock_bigquery_client, "query_and_wait"):
+        pytest.skip(
+            f"google-cloud-bigquery {google.cloud.bigquery.__version__} does not have query_and_wait"
+        )
+
+    monkeypatch.setattr(
+        pandas_gbq.features.FEATURES,
+        "_bigquery_installed_version",
+        packaging.version.parse(pandas_gbq.features.BIGQUERY_QUERY_AND_WAIT_VERSION),
+    )
+
+    df = gbq.read_gbq("SELECT 1", dialect="standard")
+    assert df is not None
+    mock_bigquery_client.query_and_wait.assert_called_once()
+
+
+def test_read_gbq_with_inferred_project_id_from_service_account_credentials_with_query(
+    monkeypatch, mock_bigquery_client, mock_service_account_credentials
+):
+    monkeypatch.setattr(
+        pandas_gbq.features.FEATURES,
+        "_bigquery_installed_version",
+        packaging.version.parse(pandas_gbq.features.BIGQUERY_MINIMUM_VERSION),
+    )
+
+    mock_service_account_credentials.project_id = "service_account_project_id"
+    df = gbq.read_gbq(
+        "SELECT 1",
+        dialect="standard",
+        credentials=mock_service_account_credentials,
+    )
+    assert df is not None
+    mock_bigquery_client.query.assert_called_once_with(
+        "SELECT 1",
+        job_config=mock.ANY,
+        location=None,
+        project="service_account_project_id",
+    )
+
+
+def test_read_gbq_with_inferred_project_id_from_service_account_credentials_with_query_and_wait(
+    monkeypatch, mock_bigquery_client, mock_service_account_credentials
+):
+    if not hasattr(mock_bigquery_client, "query_and_wait"):
+        pytest.skip(
+            f"google-cloud-bigquery {google.cloud.bigquery.__version__} does not have query_and_wait"
+        )
+
+    monkeypatch.setattr(
+        pandas_gbq.features.FEATURES,
+        "_bigquery_installed_version",
+        packaging.version.parse(pandas_gbq.features.BIGQUERY_QUERY_AND_WAIT_VERSION),
+    )
+
+    mock_service_account_credentials.project_id = "service_account_project_id"
+    df = gbq.read_gbq(
+        "SELECT 1",
+        dialect="standard",
+        credentials=mock_service_account_credentials,
+    )
+    assert df is not None
+    mock_bigquery_client.query_and_wait.assert_called_once_with(
+        "SELECT 1",
+        job_config=mock.ANY,
+        location=None,
+        project="service_account_project_id",
+        max_results=None,
+        wait_timeout=None,
+    )
+
+
+def test_read_gbq_without_inferred_project_id_from_compute_engine_credentials(
+    mock_compute_engine_credentials,
+):
+    with pytest.raises(ValueError, match="Could not determine project ID"):
+        gbq.read_gbq(
+            "SELECT 1",
+            dialect="standard",
+            credentials=mock_compute_engine_credentials,
+        )
+
+
+def test_read_gbq_with_max_results_zero(monkeypatch):
+    df = gbq.read_gbq("SELECT 1", dialect="standard", max_results=0)
+    assert df is None
+
+
+def test_read_gbq_with_max_results_ten_query(monkeypatch, mock_query_job):
+    monkeypatch.setattr(
+        pandas_gbq.features.FEATURES,
+        "_bigquery_installed_version",
+        packaging.version.parse(pandas_gbq.features.BIGQUERY_MINIMUM_VERSION),
+    )
+    df = gbq.read_gbq("SELECT 1", dialect="standard", max_results=10)
+    assert df is not None
+    mock_query_job.result.assert_called_with(max_results=10)
+
+
+def test_read_gbq_with_max_results_ten_query_and_wait(
+    monkeypatch, mock_bigquery_client
+):
+    if not hasattr(mock_bigquery_client, "query_and_wait"):
+        pytest.skip(
+            f"google-cloud-bigquery {google.cloud.bigquery.__version__} does not have query_and_wait"
+        )
+
+    monkeypatch.setattr(
+        pandas_gbq.features.FEATURES,
+        "_bigquery_installed_version",
+        packaging.version.parse(pandas_gbq.features.BIGQUERY_QUERY_AND_WAIT_VERSION),
+    )
+    df = gbq.read_gbq("SELECT 1", dialect="standard", max_results=10)
+    assert df is not None
+    mock_bigquery_client.query_and_wait.assert_called_with(
+        "SELECT 1",
+        job_config=mock.ANY,
+        location=mock.ANY,
+        project=mock.ANY,
+        max_results=10,
+        wait_timeout=None,
+    )
+
+
+@pytest.mark.parametrize(["verbose"], [(True,), (False,)])
+def test_read_gbq_with_verbose_new_pandas_warns_deprecation(monkeypatch, verbose):
+    monkeypatch.setattr(
+        type(FEATURES),
+        "pandas_has_deprecated_verbose",
+        mock.PropertyMock(return_value=True),
+    )
+    with pytest.warns(FutureWarning, match="verbose is deprecated"):
+        gbq.read_gbq("SELECT 1", project_id="my-project", verbose=verbose)
+
+
+def test_read_gbq_wo_verbose_w_new_pandas_no_warnings(monkeypatch, recwarn):
+    monkeypatch.setattr(
+        type(FEATURES),
+        "pandas_has_deprecated_verbose",
+        mock.PropertyMock(return_value=False),
+    )
+    gbq.read_gbq("SELECT 1", project_id="my-project", dialect="standard")
+    # This test was intended to check for warnings about the deprecation of
+    # the argument `verbose` (which was removed from gbq (~v0.4.0) and
+    # pandas (~v0.23.0). (See https://github.com/googleapis/python-bigquery-pandas/pull/158/files)
+    # This test should not fail upon seeing a warning in regards to a pending
+    # deprecation related to rfc9110 delimiters.
+    # TODO this and related tests have likely outlived their usefulness,
+    # consider removing.
+    for warning in recwarn.list:
+        assert "delimiter" in str(warning.message)
+
+
+def test_read_gbq_with_old_bq_raises_importerror(monkeypatch):
+    monkeypatch.setattr(google.cloud.bigquery, "__version__", "0.27.0")
+    monkeypatch.setattr(FEATURES, "_bigquery_installed_version", None)
+    with pytest.raises(ImportError, match="google-cloud-bigquery"):
+        gbq.read_gbq(
+            "SELECT 1",
+            project_id="my-project",
+        )
+
+
+def test_read_gbq_with_verbose_old_pandas_no_warnings(monkeypatch, recwarn):
+    monkeypatch.setattr(
+        type(FEATURES),
+        "pandas_has_deprecated_verbose",
+        mock.PropertyMock(return_value=False),
+    )
+    gbq.read_gbq(
+        "SELECT 1",
+        project_id="my-project",
+        dialect="standard",
+        verbose=True,
+    )
+    # This test was intended to check for warnings about the deprecation of
+    # the argument `verbose` (which was removed from gbq (~v0.4.0) and
+    # pandas (~v0.23.0). (See https://github.com/googleapis/python-bigquery-pandas/pull/158/files)
+    # This test should not fail upon seeing a warning in regards to a pending
+    # deprecation related to rfc9110 delimiters.
+    # TODO this and related tests have likely outlived their usefulness,
+    # consider removing.
+    for warning in recwarn.list:
+        assert "delimiter" in str(warning.message)
+
+
+def test_read_gbq_with_private_raises_notimplmentederror():
+    with pytest.raises(NotImplementedError, match="private_key"):
+        gbq.read_gbq(
+            "SELECT 1", project_id="my-project", private_key="path/to/key.json"
+        )
+
+
+def test_read_gbq_with_invalid_dialect():
+    with pytest.raises(ValueError, match="is not valid for dialect"):
+        gbq.read_gbq("SELECT 1", dialect="invalid")
+
+
+def test_read_gbq_with_configuration_query():
+    df = gbq.read_gbq(None, configuration={"query": {"query": "SELECT 2"}})
+    assert df is not None
+
+
+def test_read_gbq_with_configuration_duplicate_query_raises_error():
+    with pytest.raises(
+        ValueError, match="Query statement can't be specified inside config"
+    ):
+        gbq.read_gbq("SELECT 1", configuration={"query": {"query": "SELECT 2"}})
+
+
+def test_generate_bq_schema_deprecated():
+    # 11121 Deprecation of generate_bq_schema
+    with pytest.warns(FutureWarning):
+        df = DataFrame([[1, "two"], [3, "four"]])
+        gbq.generate_bq_schema(df)
+
+
+def test_load_does_not_modify_schema_arg(mock_bigquery_client):
+    """Test of Issue # 277."""
+    from google.api_core.exceptions import NotFound
+
+    # Create table with new schema.
+    mock_bigquery_client.get_table.side_effect = NotFound("nope")
+    df = DataFrame(
+        {
+            "field1": ["a", "b"],
+            "field2": [1, 2],
+            "field3": [datetime.date(2019, 1, 1), datetime.date(2019, 5, 1)],
+        }
+    )
+    original_schema = [
+        {"name": "field1", "type": "STRING", "mode": "REQUIRED"},
+        {"name": "field2", "type": "INTEGER"},
+        {"name": "field3", "type": "DATE"},
+    ]
+    original_schema_cp = copy.deepcopy(original_schema)
+    gbq.to_gbq(
+        df,
+        "dataset.schematest",
+        project_id="my-project",
+        table_schema=original_schema,
+        if_exists="fail",
+    )
+    assert original_schema == original_schema_cp
+
+    # Test again now that table exists - behavior will differ internally
+    # branch at if table.exists(table_id)
+    original_schema = [
+        {"name": "field1", "type": "STRING", "mode": "REQUIRED"},
+        {"name": "field2", "type": "INTEGER"},
+        {"name": "field3", "type": "DATE"},
+    ]
+    original_schema_cp = copy.deepcopy(original_schema)
+    gbq.to_gbq(
+        df,
+        "dataset.schematest",
+        project_id="my-project",
+        table_schema=original_schema,
+        if_exists="append",
+    )
+    assert original_schema == original_schema_cp
+
+
+def test_load_modifies_schema(mock_bigquery_client):
+    """Test of https://github.com/googleapis/python-bigquery-pandas/issues/670"""
+    from google.api_core.exceptions import NotFound
+
+    # Create table with new schema.
+    mock_bigquery_client.get_table.side_effect = NotFound("nope")
+    df = DataFrame(
+        {
+            "field1": ["a", "b"],
+            "field2": [1, 2],
+            "field3": [datetime.date(2019, 1, 1), datetime.date(2019, 5, 1)],
+        }
+    )
+    original_schema = [
+        {"name": "field1", "type": "STRING", "mode": "REQUIRED"},
+        {"name": "field2", "type": "INTEGER"},
+        {"name": "field3", "type": "DATE"},
+    ]
+    original_schema_cp = copy.deepcopy(original_schema)
+    gbq.to_gbq(
+        df,
+        "dataset.schematest",
+        project_id="my-project",
+        table_schema=original_schema,
+        if_exists="fail",
+    )
+    assert original_schema == original_schema_cp
+
+    # Test that when if_exists == "replace", the new table schema updates
+    # according to the local schema.
+    new_df = DataFrame(
+        {
+            "field1": ["a", "b"],
+            "field2": ["c", "d"],
+            "field3": [datetime.date(2019, 1, 1), datetime.date(2019, 5, 1)],
+        }
+    )
+    new_schema = [
+        {"name": "field1", "type": "STRING", "mode": "REQUIRED"},
+        {"name": "field2", "type": "STRING"},
+        {"name": "field3", "type": "DATE"},
+    ]
+    new_schema_cp = copy.deepcopy(new_schema)
+    gbq.to_gbq(
+        new_df,
+        "dataset.schematest",
+        project_id="my-project",
+        table_schema=new_schema,
+        if_exists="replace",
+    )
+    assert new_schema == new_schema_cp
+
+
+def test_read_gbq_passes_dtypes(mock_service_account_credentials, mock_row_iterator):
+    mock_service_account_credentials.project_id = "service_account_project_id"
+    df = gbq.read_gbq(
+        "SELECT 1 AS int_col",
+        dialect="standard",
+        credentials=mock_service_account_credentials,
+        dtypes={"int_col": "my-custom-dtype"},
+    )
+    assert df is not None
+
+    _, to_dataframe_kwargs = mock_row_iterator.to_dataframe.call_args
+    assert to_dataframe_kwargs["dtypes"] == {"int_col": "my-custom-dtype"}
+
+
+def test_read_gbq_use_bqstorage_api(
+    mock_service_account_credentials,
+    mock_row_iterator,
+):
+    mock_service_account_credentials.project_id = "service_account_project_id"
+    df = gbq.read_gbq(
+        "SELECT 1 AS int_col",
+        dialect="standard",
+        credentials=mock_service_account_credentials,
+        use_bqstorage_api=True,
+    )
+    assert df is not None
+
+    mock_row_iterator.to_dataframe.assert_called_once_with(
+        create_bqstorage_client=True,
+        dtypes=mock.ANY,
+        progress_bar_type=mock.ANY,
+    )
+
+
+def test_read_gbq_calls_tqdm(mock_service_account_credentials, mock_row_iterator):
+    mock_service_account_credentials.project_id = "service_account_project_id"
+    df = gbq.read_gbq(
+        "SELECT 1",
+        dialect="standard",
+        credentials=mock_service_account_credentials,
+        progress_bar_type="foobar",
+    )
+    assert df is not None
+
+    _, to_dataframe_kwargs = mock_row_iterator.to_dataframe.call_args
+    assert to_dataframe_kwargs["progress_bar_type"] == "foobar"
+
+
+def test_read_gbq_with_full_table_id(
+    mock_bigquery_client, mock_service_account_credentials
+):
+    mock_service_account_credentials.project_id = "service_account_project_id"
+    df = gbq.read_gbq(
+        "my-project.my_dataset.read_gbq_table",
+        credentials=mock_service_account_credentials,
+        project_id="param-project",
+    )
+    assert df is not None
+
+    mock_bigquery_client.query.assert_not_called()
+    sent_table = mock_bigquery_client.list_rows.call_args[0][0]
+    assert sent_table.project == "my-project"
+    assert sent_table.dataset_id == "my_dataset"
+    assert sent_table.table_id == "read_gbq_table"
+
+
+def test_read_gbq_with_partial_table_id(
+    mock_bigquery_client, mock_service_account_credentials
+):
+    mock_service_account_credentials.project_id = "service_account_project_id"
+    df = gbq.read_gbq(
+        "my_dataset.read_gbq_table",
+        credentials=mock_service_account_credentials,
+        project_id="param-project",
+    )
+    assert df is not None
+
+    mock_bigquery_client.query.assert_not_called()
+    sent_table = mock_bigquery_client.list_rows.call_args[0][0]
+    assert sent_table.project == "param-project"
+    assert sent_table.dataset_id == "my_dataset"
+    assert sent_table.table_id == "read_gbq_table"
+
+
+def test_read_gbq_bypasses_query_with_table_id_and_max_results(
+    mock_bigquery_client, mock_service_account_credentials
+):
+    mock_service_account_credentials.project_id = "service_account_project_id"
+    df = gbq.read_gbq(
+        "my-project.my_dataset.read_gbq_table",
+        credentials=mock_service_account_credentials,
+        max_results=11,
+    )
+    assert df is not None
+
+    mock_bigquery_client.query.assert_not_called()
+    sent_table = mock_bigquery_client.list_rows.call_args[0][0]
+    assert sent_table.project == "my-project"
+    assert sent_table.dataset_id == "my_dataset"
+    assert sent_table.table_id == "read_gbq_table"
+    sent_max_results = mock_bigquery_client.list_rows.call_args[1]["max_results"]
+    assert sent_max_results == 11
+
+
+def test_read_gbq_with_list_rows_error_translates_exception(
+    mock_bigquery_client, mock_service_account_credentials
+):
+    mock_bigquery_client.list_rows.side_effect = (
+        google.api_core.exceptions.NotFound("table not found"),
+    )
+
+    with pytest.raises(gbq.GenericGBQException, match="table not found"):
+        gbq.read_gbq(
+            "my-project.my_dataset.read_gbq_table",
+            credentials=mock_service_account_credentials,
+        )
+
+
+def test_run_query_with_dml_query(mock_bigquery_client, mock_query_job):
+    """
+    Don't attempt to download results from a DML query / query with no results.
+
+    https://github.com/googleapis/python-bigquery-pandas/issues/481
+    """
+    connector = _make_connector()
+    type(mock_query_job).destination = mock.PropertyMock(return_value=None)
+    connector.run_query("UPDATE tablename SET value = '';")
+    mock_bigquery_client.list_rows.assert_not_called()
diff --git a/packages/pandas-gbq/tests/unit/test_load.py b/packages/pandas-gbq/tests/unit/test_load.py
new file mode 100644
index 000000000000..bb6117817b1d
--- /dev/null
+++ b/packages/pandas-gbq/tests/unit/test_load.py
@@ -0,0 +1,387 @@
+# Copyright (c) 2017 pandas-gbq Authors All rights reserved.
+# Use of this source code is governed by a BSD-style
+# license that can be found in the LICENSE file.
+
+# -*- coding: utf-8 -*-
+
+import datetime
+import decimal
+from io import StringIO
+import textwrap
+
+import db_dtypes
+import numpy
+import pandas
+import pandas.testing
+import pytest
+
+from pandas_gbq import exceptions, load
+
+
+def load_method(bqclient, api_method):
+    return bqclient.load_table_from_dataframe
+
+
+def test_encode_chunk_with_unicode():
+    """Test that a dataframe containing unicode can be encoded as a file.
+
+    See: https://github.com/pydata/pandas-gbq/issues/106
+    """
+    df = pandas.DataFrame(
+        numpy.random.randn(6, 4), index=range(6), columns=list("ABCD")
+    )
+    df["s"] = "信用卡"
+    csv_buffer = load.encode_chunk(df)
+    csv_bytes = csv_buffer.read()
+    csv_string = csv_bytes.decode("utf-8")
+    assert "信用卡" in csv_string
+
+
+def test_encode_chunk_with_floats():
+    """Test that floats in a dataframe are encoded with at most 17 significant
+        figures.
+
+    See: https://github.com/pydata/pandas-gbq/issues/192 and
+    https://github.com/pydata/pandas-gbq/issues/326
+    """
+    input_csv = textwrap.dedent(
+        """01/01/17 23:00,0.14285714285714285,4
+        01/02/17 22:00,1.05148,3
+        01/03/17 21:00,1.05153,2
+        01/04/17 20:00,3.141592653589793,1
+        01/05/17 19:00,2.0988936657440586e+43,0
+        """
+    )
+    input_df = pandas.read_csv(
+        StringIO(input_csv), header=None, float_precision="round_trip"
+    )
+    csv_buffer = load.encode_chunk(input_df)
+    round_trip = pandas.read_csv(csv_buffer, header=None, float_precision="round_trip")
+    pandas.testing.assert_frame_equal(
+        round_trip,
+        input_df,
+        check_exact=True,
+    )
+
+
+def test_encode_chunk_with_newlines():
+    """See: https://github.com/pydata/pandas-gbq/issues/180"""
+    df = pandas.DataFrame({"s": ["abcd", "ef\ngh", "ij\r\nkl"]})
+    csv_buffer = load.encode_chunk(df)
+    csv_bytes = csv_buffer.read()
+    csv_string = csv_bytes.decode("utf-8")
+    assert "abcd" in csv_string
+    assert '"ef\ngh"' in csv_string
+    assert '"ij\r\nkl"' in csv_string
+
+
+def test_split_dataframe():
+    df = pandas.DataFrame(numpy.random.randn(6, 4), index=range(6))
+    chunks = list(load.split_dataframe(df, chunksize=2))
+    assert len(chunks) == 3
+    remaining, chunk = chunks[0]
+    assert remaining == 4
+    assert len(chunk.index) == 2
+
+
+def test_encode_chunks_with_chunksize_none():
+    df = pandas.DataFrame(numpy.random.randn(6, 4), index=range(6))
+    chunks = list(load.split_dataframe(df))
+    assert len(chunks) == 1
+    remaining, chunk = chunks[0]
+    assert remaining == 0
+    assert len(chunk.index) == 6
+
+
+def test_load_csv_from_dataframe_allows_client_to_generate_schema(mock_bigquery_client):
+    import google.cloud.bigquery
+
+    df = pandas.DataFrame({"int_col": [1, 2, 3]})
+    destination = google.cloud.bigquery.TableReference.from_string(
+        "my-project.my_dataset.my_table"
+    )
+
+    _ = list(
+        load.load_csv_from_dataframe(
+            mock_bigquery_client, df, destination, None, None, None, None
+        )
+    )
+
+    mock_load = mock_bigquery_client.load_table_from_dataframe
+    assert mock_load.called
+    _, kwargs = mock_load.call_args
+    assert "job_config" in kwargs
+    assert kwargs["job_config"].schema is None
+
+
+def test_load_csv_from_file_generates_schema(mock_bigquery_client):
+    import google.cloud.bigquery
+
+    df = pandas.DataFrame(
+        {
+            "int_col": [1, 2, 3],
+            "bool_col": [True, False, True],
+            "float_col": [0.0, 1.25, -2.75],
+            "string_col": ["a", "b", "c"],
+            "datetime_col": pandas.Series(
+                [
+                    "2021-12-21 13:28:40.123789",
+                    "2000-01-01 11:10:09",
+                    "2040-10-31 23:59:59.999999",
+                ],
+                dtype="datetime64[ns]",
+            ),
+            "timestamp_col": pandas.Series(
+                [
+                    "2021-12-21 13:28:40.123789",
+                    "2000-01-01 11:10:09",
+                    "2040-10-31 23:59:59.999999",
+                ],
+                dtype="datetime64[ns]",
+            ).dt.tz_localize(datetime.timezone.utc),
+        }
+    )
+    destination = google.cloud.bigquery.TableReference.from_string(
+        "my-project.my_dataset.my_table"
+    )
+
+    _ = list(
+        load.load_csv_from_file(
+            mock_bigquery_client, df, destination, None, None, None, None
+        )
+    )
+
+    mock_load = mock_bigquery_client.load_table_from_file
+    assert mock_load.called
+    _, kwargs = mock_load.call_args
+    assert "job_config" in kwargs
+    sent_schema = kwargs["job_config"].schema
+    assert len(sent_schema) == len(df.columns)
+    assert sent_schema[0].name == "int_col"
+    assert sent_schema[0].field_type == "INTEGER"
+    assert sent_schema[1].name == "bool_col"
+    assert sent_schema[1].field_type == "BOOLEAN"
+    assert sent_schema[2].name == "float_col"
+    assert sent_schema[2].field_type == "FLOAT"
+    assert sent_schema[3].name == "string_col"
+    assert sent_schema[3].field_type == "STRING"
+    assert sent_schema[4].name == "datetime_col"
+    assert sent_schema[4].field_type == "DATETIME"
+    assert sent_schema[5].name == "timestamp_col"
+    assert sent_schema[5].field_type == "TIMESTAMP"
+
+
+@pytest.mark.parametrize(
+    ["api_method"],
+    [("load_parquet",), ("load_csv",)],
+)
+def test_load_chunks_omits_policy_tags(monkeypatch, mock_bigquery_client, api_method):
+    """Ensure that policyTags are omitted.
+
+    We don't want to change the policyTags via a load job, as this can cause
+    403 error. See: https://github.com/googleapis/python-bigquery/pull/557
+    """
+    import google.cloud.bigquery
+
+    df = pandas.DataFrame({"col1": [1, 2, 3]})
+    destination = google.cloud.bigquery.TableReference.from_string(
+        "my-project.my_dataset.my_table"
+    )
+    schema = {
+        "fields": [
+            {"name": "col1", "type": "INT64", "policyTags": {"names": ["tag1", "tag2"]}}
+        ]
+    }
+
+    _ = list(
+        load.load_chunks(
+            mock_bigquery_client, df, destination, schema=schema, api_method=api_method
+        )
+    )
+
+    mock_load = load_method(mock_bigquery_client, api_method=api_method)
+    assert mock_load.called
+    _, kwargs = mock_load.call_args
+    assert "job_config" in kwargs
+    sent_field = kwargs["job_config"].schema[0].to_api_repr()
+    assert "policyTags" not in sent_field
+
+
+def test_load_chunks_with_invalid_api_method():
+    with pytest.raises(ValueError, match="Got unexpected api_method:"):
+        load.load_chunks(None, None, None, None, api_method="not_a_thing")
+
+
+def test_load_parquet_allows_client_to_generate_schema(mock_bigquery_client):
+    import google.cloud.bigquery
+
+    df = pandas.DataFrame({"int_col": [1, 2, 3]})
+    destination = google.cloud.bigquery.TableReference.from_string(
+        "my-project.my_dataset.my_table"
+    )
+
+    load.load_parquet(
+        mock_bigquery_client,
+        df,
+        destination,
+        None,
+        None,
+        None,
+    )
+
+    mock_load = mock_bigquery_client.load_table_from_dataframe
+    assert mock_load.called
+    _, kwargs = mock_load.call_args
+    assert "job_config" in kwargs
+    assert kwargs["job_config"].schema is None
+
+
+def test_load_parquet_with_bad_conversion(mock_bigquery_client):
+    import google.cloud.bigquery
+    import pyarrow
+
+    mock_bigquery_client.load_table_from_dataframe.side_effect = (
+        pyarrow.lib.ArrowInvalid()
+    )
+    df = pandas.DataFrame({"int_col": [1, 2, 3]})
+    destination = google.cloud.bigquery.TableReference.from_string(
+        "my-project.my_dataset.my_table"
+    )
+
+    with pytest.raises(exceptions.ConversionError):
+        load.load_parquet(mock_bigquery_client, df, destination, None, None, None)
+
+
+@pytest.mark.parametrize(
+    ("numeric_type",),
+    (
+        ("NUMERIC",),
+        ("DECIMAL",),
+        ("BIGNUMERIC",),
+        ("BIGDECIMAL",),
+        ("numeric",),
+        ("decimal",),
+        ("bignumeric",),
+        ("bigdecimal",),
+    ),
+)
+def test_cast_dataframe_for_parquet_w_float_numeric(numeric_type):
+    dataframe = pandas.DataFrame(
+        {
+            "row_num": [0, 1, 2],
+            "num_col": pandas.Series(
+                # Very much not recommend as the whole point of NUMERIC is to
+                # be more accurate than a floating point number, but tested to
+                # keep compatibility with CSV-based uploads. See:
+                # https://github.com/googleapis/python-bigquery-pandas/issues/421
+                [1.25, -1.25, 42.5],
+                dtype="float64",
+            ),
+            "row_num_2": [0, 1, 2],
+        },
+        # Use multiple columns to ensure column order is maintained.
+        columns=["row_num", "num_col", "row_num_2"],
+    )
+    schema = {
+        "fields": [
+            {"name": "num_col", "type": numeric_type},
+            {"name": "not_in_df", "type": "IGNORED"},
+        ]
+    }
+    result = load.cast_dataframe_for_parquet(dataframe, schema)
+    expected = pandas.DataFrame(
+        {
+            "row_num": [0, 1, 2],
+            "num_col": pandas.Series(
+                [decimal.Decimal(1.25), decimal.Decimal(-1.25), decimal.Decimal(42.5)],
+                dtype="object",
+            ),
+            "row_num_2": [0, 1, 2],
+        },
+        columns=["row_num", "num_col", "row_num_2"],
+    )
+    pandas.testing.assert_frame_equal(result, expected)
+
+
+def test_cast_dataframe_for_parquet_w_string_date():
+    dataframe = pandas.DataFrame(
+        {
+            "row_num": [0, 1, 2],
+            "date_col": pandas.Series(
+                ["2021-04-17", "1999-12-31", "2038-01-19"],
+                dtype="object",
+            ),
+            "row_num_2": [0, 1, 2],
+        },
+        # Use multiple columns to ensure column order is maintained.
+        columns=["row_num", "date_col", "row_num_2"],
+    )
+    schema = {
+        "fields": [
+            {"name": "date_col", "type": "DATE"},
+            {"name": "not_in_df", "type": "IGNORED"},
+        ]
+    }
+    result = load.cast_dataframe_for_parquet(dataframe, schema)
+    expected = pandas.DataFrame(
+        {
+            "row_num": [0, 1, 2],
+            "date_col": pandas.Series(
+                ["2021-04-17", "1999-12-31", "2038-01-19"],
+                dtype=db_dtypes.DateDtype(),
+            ),
+            "row_num_2": [0, 1, 2],
+        },
+        columns=["row_num", "date_col", "row_num_2"],
+    )
+    pandas.testing.assert_frame_equal(result, expected)
+
+
+def test_cast_dataframe_for_parquet_ignores_repeated_fields():
+    dataframe = pandas.DataFrame(
+        {
+            "row_num": [0, 1, 2],
+            "repeated_col": pandas.Series(
+                [
+                    [datetime.date(2021, 4, 17)],
+                    [datetime.date(199, 12, 31)],
+                    [datetime.date(2038, 1, 19)],
+                ],
+                dtype="object",
+            ),
+            "row_num_2": [0, 1, 2],
+        },
+        # Use multiple columns to ensure column order is maintained.
+        columns=["row_num", "repeated_col", "row_num_2"],
+    )
+    expected = dataframe.copy()
+    schema = {"fields": [{"name": "repeated_col", "type": "DATE", "mode": "REPEATED"}]}
+    result = load.cast_dataframe_for_parquet(dataframe, schema)
+    pandas.testing.assert_frame_equal(result, expected)
+
+
+def test_cast_dataframe_for_parquet_w_null_fields():
+    dataframe = pandas.DataFrame({"int_col": [0, 1, 2], "str_col": ["a", "b", "c"]})
+    expected = dataframe.copy()
+    schema = {"fields": None}
+    result = load.cast_dataframe_for_parquet(dataframe, schema)
+    pandas.testing.assert_frame_equal(result, expected)
+
+
+# Verifies null numerics are properly handled
+# https://github.com/googleapis/python-bigquery-pandas/issues/719
+def test_cast_dataframe_for_parquet_w_null_numerics():
+    from decimal import Decimal
+
+    nans = pandas.Series([Decimal("3.14"), Decimal("nan"), None, pandas.NA])
+    dataframe = pandas.DataFrame({"A": nans})
+
+    schema = {"fields": [{"name": "A", "type": "BIGNUMERIC"}]}
+    result = load.cast_dataframe_for_parquet(dataframe, schema)
+
+    # pandas.testing.assert_frame_equal() doesn't distinguish Decimal("NaN")
+    # vs. None, verify Decimal("NaN") directly.
+    # https://github.com/pandas-dev/pandas/issues/18463
+    assert result["A"][1].is_nan()
+    assert result["A"][2].is_nan()
+    assert result["A"][3].is_nan()
diff --git a/packages/pandas-gbq/tests/unit/test_query.py b/packages/pandas-gbq/tests/unit/test_query.py
new file mode 100644
index 000000000000..2437fa02d897
--- /dev/null
+++ b/packages/pandas-gbq/tests/unit/test_query.py
@@ -0,0 +1,207 @@
+# Copyright (c) 2017 pandas-gbq Authors All rights reserved.
+# Use of this source code is governed by a BSD-style
+# license that can be found in the LICENSE file.
+
+from __future__ import annotations
+
+import concurrent.futures
+import datetime
+from unittest import mock
+
+import freezegun
+import google.api_core.exceptions
+import google.auth.exceptions
+import google.cloud.bigquery
+import pytest
+
+import pandas_gbq.exceptions
+import pandas_gbq.gbq
+import pandas_gbq.query as module_under_test
+
+
+def _make_connector(project_id: str = "some-project", **kwargs):
+    return pandas_gbq.gbq.GbqConnector(project_id, **kwargs)
+
+
+def test_query_and_wait_via_client_library_apierror_raises_genericgbqexception(
+    mock_bigquery_client,
+):
+    if not hasattr(mock_bigquery_client, "query_and_wait"):
+        pytest.skip(
+            f"google-cloud-bigquery {google.cloud.bigquery.__version__} does not have query_and_wait"
+        )
+
+    connector = _make_connector()
+    connector.client = mock_bigquery_client
+    mock_bigquery_client.query_and_wait.side_effect = (
+        google.api_core.exceptions.GoogleAPIError()
+    )
+
+    with pytest.raises(pandas_gbq.exceptions.GenericGBQException):
+        module_under_test.query_and_wait_via_client_library(
+            connector,
+            mock_bigquery_client,
+            "SELECT 1",
+            job_config=google.cloud.bigquery.QueryJobConfig(),
+            location=None,
+            project_id=None,
+            max_results=None,
+            timeout_ms=None,
+        )
+
+
+def test_query_and_wait_via_client_library_refresherror_raises_accessdenied_service_account(
+    mock_bigquery_client,
+):
+    if not hasattr(mock_bigquery_client, "query_and_wait"):
+        pytest.skip(
+            f"google-cloud-bigquery {google.cloud.bigquery.__version__} does not have query_and_wait"
+        )
+
+    connector = _make_connector()
+    connector.private_key = "abc"
+    connector.client = mock_bigquery_client
+    mock_bigquery_client.query_and_wait.side_effect = (
+        google.auth.exceptions.RefreshError()
+    )
+
+    with pytest.raises(pandas_gbq.exceptions.AccessDenied, match="service account"):
+        module_under_test.query_and_wait_via_client_library(
+            connector,
+            mock_bigquery_client,
+            "SELECT 1",
+            job_config=google.cloud.bigquery.QueryJobConfig(),
+            location=None,
+            project_id=None,
+            max_results=None,
+            timeout_ms=None,
+        )
+
+
+def test_query_and_wait_via_client_library_refresherror_raises_accessdenied_user_credentials(
+    mock_bigquery_client,
+):
+    if not hasattr(mock_bigquery_client, "query_and_wait"):
+        pytest.skip(
+            f"google-cloud-bigquery {google.cloud.bigquery.__version__} does not have query_and_wait"
+        )
+
+    connector = _make_connector()
+    connector.client = mock_bigquery_client
+    mock_bigquery_client.query_and_wait.side_effect = (
+        google.auth.exceptions.RefreshError()
+    )
+
+    with pytest.raises(pandas_gbq.exceptions.AccessDenied, match="revoked or expired"):
+        module_under_test.query_and_wait_via_client_library(
+            connector,
+            mock_bigquery_client,
+            "SELECT 1",
+            job_config=google.cloud.bigquery.QueryJobConfig(),
+            location=None,
+            project_id=None,
+            max_results=None,
+            timeout_ms=None,
+        )
+
+
+def test_query_and_wait_via_client_library_timeout_raises_querytimeout(
+    mock_bigquery_client,
+):
+    if not hasattr(mock_bigquery_client, "query_and_wait"):
+        pytest.skip(
+            f"google-cloud-bigquery {google.cloud.bigquery.__version__} does not have query_and_wait"
+        )
+
+    connector = _make_connector()
+    connector.client = mock_bigquery_client
+    connector.start = datetime.datetime(2020, 1, 1).timestamp()
+
+    mock_bigquery_client.query_and_wait.side_effect = concurrent.futures.TimeoutError(
+        "fake timeout"
+    )
+
+    with freezegun.freeze_time(
+        "2020-01-01 00:00:00", auto_tick_seconds=15
+    ), pytest.raises(pandas_gbq.exceptions.QueryTimeout):
+        module_under_test.query_and_wait_via_client_library(
+            connector,
+            mock_bigquery_client,
+            "SELECT 1",
+            job_config=google.cloud.bigquery.QueryJobConfig(),
+            location="EU",
+            project_id="test-query-and-wait",
+            max_results=123,
+            timeout_ms=500,
+        )
+
+    mock_bigquery_client.query_and_wait.assert_called_with(
+        "SELECT 1",
+        job_config=mock.ANY,
+        location="EU",
+        project="test-query-and-wait",
+        max_results=123,
+        wait_timeout=0.5,
+    )
+
+
+@pytest.mark.parametrize(
+    ["size_in_bytes", "formatted_text"],
+    [
+        (999, "999.0 B"),
+        (1024, "1.0 KB"),
+        (1099, "1.1 KB"),
+        (1044480, "1020.0 KB"),
+        (1048576, "1.0 MB"),
+        (1048576000, "1000.0 MB"),
+        (1073741824, "1.0 GB"),
+        (1.099512e12, "1.0 TB"),
+        (1.125900e15, "1.0 PB"),
+        (1.152922e18, "1.0 EB"),
+        (1.180592e21, "1.0 ZB"),
+        (1.208926e24, "1.0 YB"),
+        (1.208926e28, "10000.0 YB"),
+    ],
+)
+def test_query_response_bytes(size_in_bytes, formatted_text):
+    assert module_under_test.sizeof_fmt(size_in_bytes) == formatted_text
+
+
+def test__wait_for_query_job_exits_when_done(mock_bigquery_client):
+    connector = _make_connector()
+    connector.client = mock_bigquery_client
+    connector.start = datetime.datetime(2020, 1, 1).timestamp()
+
+    mock_query = mock.create_autospec(google.cloud.bigquery.QueryJob)
+    type(mock_query).state = mock.PropertyMock(side_effect=("RUNNING", "DONE"))
+    mock_query.result.side_effect = concurrent.futures.TimeoutError("fake timeout")
+
+    with freezegun.freeze_time("2020-01-01 00:00:00", tick=False):
+        module_under_test._wait_for_query_job(
+            connector, mock_bigquery_client, mock_query, 60
+        )
+
+    mock_bigquery_client.cancel_job.assert_not_called()
+
+
+def test__wait_for_query_job_cancels_after_timeout(mock_bigquery_client):
+    connector = _make_connector()
+    connector.client = mock_bigquery_client
+    connector.start = datetime.datetime(2020, 1, 1).timestamp()
+
+    mock_query = mock.create_autospec(google.cloud.bigquery.QueryJob)
+    mock_query.job_id = "a-random-id"
+    mock_query.location = "job-location"
+    mock_query.state = "RUNNING"
+    mock_query.result.side_effect = concurrent.futures.TimeoutError("fake timeout")
+
+    with freezegun.freeze_time(
+        "2020-01-01 00:00:00", auto_tick_seconds=15
+    ), pytest.raises(pandas_gbq.exceptions.QueryTimeout):
+        module_under_test._wait_for_query_job(
+            connector, mock_bigquery_client, mock_query, 60
+        )
+
+    mock_bigquery_client.cancel_job.assert_called_with(
+        "a-random-id", location="job-location"
+    )
diff --git a/packages/pandas-gbq/tests/unit/test_schema.py b/packages/pandas-gbq/tests/unit/test_schema.py
new file mode 100644
index 000000000000..0da16bafd9b6
--- /dev/null
+++ b/packages/pandas-gbq/tests/unit/test_schema.py
@@ -0,0 +1,338 @@
+# Copyright (c) 2017 pandas-gbq Authors All rights reserved.
+# Use of this source code is governed by a BSD-style
+# license that can be found in the LICENSE file.
+
+import datetime
+from typing import Any, Dict, List
+
+import google.cloud.bigquery
+import pandas
+import pyarrow
+import pytest
+
+import pandas_gbq
+import pandas_gbq.gbq
+import pandas_gbq.schema
+
+
+@pytest.mark.parametrize(
+    "original_fields,dataframe_fields",
+    [
+        (
+            [
+                {"name": "A", "type": "FLOAT"},
+                {"name": "B", "type": "FLOAT64"},
+                {"name": "C", "type": "STRING"},
+            ],
+            [{"name": "A", "type": "FLOAT64"}, {"name": "B", "type": "FLOAT"}],
+        ),
+        # Original schema from API may contain legacy SQL datatype names.
+        # https://github.com/pydata/pandas-gbq/issues/322
+        (
+            [{"name": "A", "type": "INTEGER"}],
+            [{"name": "A", "type": "INT64"}],
+        ),
+        (
+            [{"name": "A", "type": "BOOL"}],
+            [{"name": "A", "type": "BOOLEAN"}],
+        ),
+        (
+            # TODO: include sub-fields when struct uploads are supported.
+            [{"name": "A", "type": "STRUCT"}],
+            [{"name": "A", "type": "RECORD"}],
+        ),
+    ],
+)
+def test_schema_is_subset_passes_if_subset(original_fields, dataframe_fields):
+    # Issue #24 schema_is_subset indicates whether the schema of the
+    # dataframe is a subset of the schema of the bigquery table
+    table_schema = {"fields": original_fields}
+    tested_schema = {"fields": dataframe_fields}
+    assert pandas_gbq.schema.schema_is_subset(table_schema, tested_schema)
+
+
+def test_schema_is_subset_fails_if_not_subset():
+    table_schema = {
+        "fields": [
+            {"name": "A", "type": "FLOAT"},
+            {"name": "B", "type": "FLOAT"},
+            {"name": "C", "type": "STRING"},
+        ]
+    }
+    tested_schema = {
+        "fields": [{"name": "A", "type": "FLOAT"}, {"name": "C", "type": "FLOAT"}]
+    }
+    assert not pandas_gbq.schema.schema_is_subset(table_schema, tested_schema)
+
+
+@pytest.mark.parametrize(
+    "dataframe,expected_schema",
+    [
+        pytest.param(
+            pandas.DataFrame(data={"col1": [object()]}),
+            {"fields": [{"name": "col1", "type": "DEFAULT_TYPE"}]},
+            id="default-type-fails-pyarrow-conversion",
+        ),
+        (
+            pandas.DataFrame(data={"col1": [1, 2, 3]}),
+            {"fields": [{"name": "col1", "type": "INTEGER"}]},
+        ),
+        (
+            pandas.DataFrame(data={"col1": [True, False]}),
+            {"fields": [{"name": "col1", "type": "BOOLEAN"}]},
+        ),
+        (
+            pandas.DataFrame(data={"col1": [1.0, 3.14]}),
+            {"fields": [{"name": "col1", "type": "FLOAT"}]},
+        ),
+        (
+            pandas.DataFrame(data={"col1": ["hello", "world"]}),
+            {"fields": [{"name": "col1", "type": "STRING"}]},
+        ),
+        pytest.param(
+            # No time zone -> DATETIME,
+            # Time zone -> TIMESTAMP
+            # See: https://github.com/googleapis/python-bigquery-pandas/issues/450
+            pandas.DataFrame(
+                data={
+                    "object1": pandas.Series([datetime.datetime.now()], dtype="object"),
+                    "object2": pandas.Series(
+                        [datetime.datetime.now(datetime.timezone.utc)], dtype="object"
+                    ),
+                    "datetime1": pandas.Series(
+                        [datetime.datetime.now()], dtype="datetime64[ns]"
+                    ),
+                    "datetime2": pandas.Series(
+                        [datetime.datetime.now(datetime.timezone.utc)],
+                        dtype="datetime64[ns, UTC]",
+                    ),
+                }
+            ),
+            {
+                "fields": [
+                    {"name": "object1", "type": "DATETIME"},
+                    {"name": "object2", "type": "TIMESTAMP"},
+                    {"name": "datetime1", "type": "DATETIME"},
+                    {"name": "datetime2", "type": "TIMESTAMP"},
+                ]
+            },
+            id="issue450-datetime",
+        ),
+        (
+            pandas.DataFrame(
+                data={
+                    "col0": [datetime.datetime.now(datetime.timezone.utc)],
+                    "col1": [datetime.datetime.now()],
+                    "col2": ["hello"],
+                    "col3": [3.14],
+                    "col4": [True],
+                    "col5": [4],
+                }
+            ),
+            {
+                "fields": [
+                    {"name": "col0", "type": "TIMESTAMP"},
+                    {"name": "col1", "type": "DATETIME"},
+                    {"name": "col2", "type": "STRING"},
+                    {"name": "col3", "type": "FLOAT"},
+                    {"name": "col4", "type": "BOOLEAN"},
+                    {"name": "col5", "type": "INTEGER"},
+                ]
+            },
+        ),
+        pytest.param(
+            # uint8, which is the result from get_dummies, should be INTEGER.
+            # https://github.com/googleapis/python-bigquery-pandas/issues/616
+            pandas.DataFrame({"col": [0, 1]}, dtype="uint8"),
+            {"fields": [{"name": "col", "type": "INTEGER"}]},
+            id="issue616-uint8",
+        ),
+        pytest.param(
+            # object column containing dictionaries should load to STRUCT.
+            # https://github.com/googleapis/python-bigquery-pandas/issues/452
+            pandas.DataFrame(
+                {
+                    "my_struct": pandas.Series(
+                        [{"test": "str1"}, {"test": "str2"}, {"test": "str3"}],
+                        dtype="object",
+                    ),
+                }
+            ),
+            {
+                "fields": [
+                    {
+                        "name": "my_struct",
+                        "type": "RECORD",
+                        "fields": [
+                            {"name": "test", "type": "STRING", "mode": "NULLABLE"}
+                        ],
+                    }
+                ]
+            },
+            id="issue452-struct",
+        ),
+        pytest.param(
+            pandas.DataFrame(
+                {
+                    "object": pandas.Series([[], ["abc"], []], dtype="object"),
+                    "list": pandas.Series(
+                        [[], [1, 2, 3], []],
+                        dtype=pandas.ArrowDtype(pyarrow.list_(pyarrow.int64()))
+                        if hasattr(pandas, "ArrowDtype")
+                        else "object",
+                    ),
+                    "list_of_struct": pandas.Series(
+                        [[], [{"test": 123.0}], []],
+                        dtype=pandas.ArrowDtype(
+                            pyarrow.list_(pyarrow.struct([("test", pyarrow.float64())]))
+                        )
+                        if hasattr(pandas, "ArrowDtype")
+                        else "object",
+                    ),
+                    "list_of_unknown": [[], [], []],
+                    "list_of_null": [[None, None], [None], [None, None]],
+                }
+            ),
+            {
+                "fields": [
+                    {"name": "object", "type": "STRING", "mode": "REPEATED"},
+                    {"name": "list", "type": "INTEGER", "mode": "REPEATED"},
+                    {
+                        "name": "list_of_struct",
+                        "type": "RECORD",
+                        "mode": "REPEATED",
+                        "fields": [
+                            {"name": "test", "type": "FLOAT", "mode": "NULLABLE"},
+                        ],
+                    },
+                    # Use DEFAULT_TYPE because there are no values to detect a type.
+                    {
+                        "name": "list_of_unknown",
+                        "type": "DEFAULT_TYPE",
+                        "mode": "REPEATED",
+                    },
+                    {
+                        "name": "list_of_null",
+                        "type": "DEFAULT_TYPE",
+                        "mode": "REPEATED",
+                    },
+                ],
+            },
+            id="array",
+        ),
+        pytest.param(
+            # If a struct contains only nulls in a sub-field, use the default
+            # type for subfields without a type we can determine.
+            # https://github.com/googleapis/python-bigquery-pandas/issues/836
+            pandas.DataFrame(
+                {
+                    "id": [0, 1],
+                    "positions": [{"state": None}, {"state": None}],
+                },
+            ),
+            {
+                "fields": [
+                    {"name": "id", "type": "INTEGER"},
+                    {
+                        "name": "positions",
+                        "type": "RECORD",
+                        "fields": [
+                            {
+                                "name": "state",
+                                "type": "DEFAULT_TYPE",
+                                "mode": "NULLABLE",
+                            },
+                        ],
+                    },
+                ],
+            },
+            id="issue832-null-struct-field",
+        ),
+    ],
+)
+def test_generate_bq_schema(dataframe, expected_schema):
+    schema = pandas_gbq.gbq._generate_bq_schema(dataframe, default_type="DEFAULT_TYPE")
+
+    # NULLABLE is the default mode.
+    for field in expected_schema["fields"]:
+        if "mode" not in field:
+            field["mode"] = "NULLABLE"
+
+    assert schema == expected_schema
+
+
+@pytest.mark.parametrize(
+    "schema_old,schema_new,expected_output",
+    [
+        (
+            {"fields": [{"name": "col1", "type": "INTEGER"}]},
+            {"fields": [{"name": "col2", "type": "TIMESTAMP"}]},
+            # Ignore fields that aren't in the DataFrame.
+            {"fields": [{"name": "col1", "type": "INTEGER"}]},
+        ),
+        (
+            {"fields": [{"name": "col1", "type": "INTEGER"}]},
+            {"fields": [{"name": "col1", "type": "BOOLEAN"}]},
+            # Update type for fields that are in the DataFrame.
+            {"fields": [{"name": "col1", "type": "BOOLEAN"}]},
+        ),
+        (
+            {
+                "fields": [
+                    {"name": "col1", "type": "INTEGER"},
+                    {"name": "col2", "type": "INTEGER"},
+                ]
+            },
+            {
+                "fields": [
+                    {"name": "col2", "type": "BOOLEAN"},
+                    {"name": "col3", "type": "FLOAT"},
+                ]
+            },
+            {
+                "fields": [
+                    {"name": "col1", "type": "INTEGER"},
+                    {"name": "col2", "type": "BOOLEAN"},
+                ]
+            },
+        ),
+    ],
+)
+def test_update_schema(schema_old, schema_new, expected_output):
+    output = pandas_gbq.schema.update_schema(schema_old, schema_new)
+    assert output == expected_output
+
+
+@pytest.mark.parametrize(
+    ["bq_schema", "expected"],
+    [
+        ([], {"fields": []}),
+        (
+            [google.cloud.bigquery.SchemaField("test_col", "STRING")],
+            {"fields": [{"name": "test_col", "type": "STRING", "mode": "NULLABLE"}]},
+        ),
+        (
+            [google.cloud.bigquery.SchemaField("test_col", "STRING", mode="REQUIRED")],
+            {"fields": [{"name": "test_col", "type": "STRING", "mode": "REQUIRED"}]},
+        ),
+        (
+            [
+                google.cloud.bigquery.SchemaField("test1", "STRING"),
+                google.cloud.bigquery.SchemaField("test2", "INTEGER"),
+            ],
+            {
+                "fields": [
+                    {"name": "test1", "type": "STRING", "mode": "NULLABLE"},
+                    {"name": "test2", "type": "INTEGER", "mode": "NULLABLE"},
+                ]
+            },
+        ),
+    ],
+)
+def test_to_pandas_gbq(
+    bq_schema: List[google.cloud.bigquery.SchemaField], expected: Dict[str, Any]
+):
+    import pandas_gbq.schema
+
+    result = pandas_gbq.schema.to_pandas_gbq(bq_schema)
+    assert result == expected
diff --git a/packages/pandas-gbq/tests/unit/test_timestamp.py b/packages/pandas-gbq/tests/unit/test_timestamp.py
new file mode 100644
index 000000000000..682619fe30eb
--- /dev/null
+++ b/packages/pandas-gbq/tests/unit/test_timestamp.py
@@ -0,0 +1,78 @@
+# Copyright (c) 2017 pandas-gbq Authors All rights reserved.
+# Use of this source code is governed by a BSD-style
+# license that can be found in the LICENSE file.
+
+"""Unit tests for TIMESTAMP data type helpers."""
+
+import pandas
+import pandas.testing
+import pytest
+
+
+@pytest.fixture
+def module_under_test():
+    from pandas_gbq import timestamp
+
+    return timestamp
+
+
+def test_localize_df_with_empty_dataframe(module_under_test):
+    df = pandas.DataFrame({"timestamp_col": [], "other_col": []})
+    original = df.copy()
+    bq_schema = [
+        {"name": "timestamp_col", "type": "TIMESTAMP"},
+        {"name": "other_col", "type": "STRING"},
+    ]
+
+    localized = module_under_test.localize_df(df, bq_schema)
+
+    # Empty DataFrames should be unchanged.
+    assert localized is df
+    pandas.testing.assert_frame_equal(localized, original)
+
+
+def test_localize_df_with_no_timestamp_columns(module_under_test):
+    df = pandas.DataFrame({"integer_col": [1, 2, 3], "float_col": [0.1, 0.2, 0.3]})
+    original = df.copy()
+    bq_schema = [
+        {"name": "integer_col", "type": "INTEGER"},
+        {"name": "float_col", "type": "FLOAT"},
+    ]
+
+    localized = module_under_test.localize_df(df, bq_schema)
+
+    # DataFrames with no TIMESTAMP columns should be unchanged.
+    assert localized is df
+    pandas.testing.assert_frame_equal(localized, original)
+
+
+def test_localize_df_with_timestamp_column(module_under_test):
+    df = pandas.DataFrame(
+        {
+            "integer_col": [1, 2, 3],
+            "timestamp_col": pandas.Series(
+                ["2011-01-01 01:02:03", "2012-02-02 04:05:06", "2013-03-03 07:08:09"],
+                dtype="datetime64[ns]",
+            ),
+            "float_col": [0.1, 0.2, 0.3],
+            "repeated_col": pandas.Series(
+                [
+                    ["2011-01-01 01:02:03"],
+                    ["2012-02-02 04:05:06"],
+                    ["2013-03-03 07:08:09"],
+                ],
+                dtype="object",
+            ),
+        }
+    )
+    expected = df.copy()
+    expected["timestamp_col"] = df["timestamp_col"].dt.tz_localize("UTC")
+    bq_schema = [
+        {"name": "integer_col", "type": "INTEGER"},
+        {"name": "timestamp_col", "type": "TIMESTAMP"},
+        {"name": "float_col", "type": "FLOAT"},
+        {"name": "repeated_col", "type": "TIMESTAMP", "mode": "REPEATED"},
+    ]
+
+    localized = module_under_test.localize_df(df, bq_schema)
+    pandas.testing.assert_frame_equal(localized, expected)
diff --git a/packages/pandas-gbq/tests/unit/test_to_gbq.py b/packages/pandas-gbq/tests/unit/test_to_gbq.py
new file mode 100644
index 000000000000..6f00ccf8b168
--- /dev/null
+++ b/packages/pandas-gbq/tests/unit/test_to_gbq.py
@@ -0,0 +1,326 @@
+# Copyright (c) 2021 pandas-gbq Authors All rights reserved.
+# Use of this source code is governed by a BSD-style
+# license that can be found in the LICENSE file.
+
+
+import os
+import pathlib
+import tempfile
+import unittest.mock as mock
+
+import google.api_core.exceptions
+import google.cloud.bigquery
+import pandas as pd
+from pandas import DataFrame
+import pytest
+
+from pandas_gbq import gbq
+
+Path = pathlib.Path
+
+
+class FakeDataFrame:
+    """A fake bigframes DataFrame to avoid depending on bigframes."""
+
+    def to_gbq(self):
+        """Fake to_gbq() to mimic a bigframes object."""
+
+    def to_pandas(self):
+        """Fake to_pandas() to mimic a bigframes object."""
+
+
+@pytest.fixture
+def expected_load_method(mock_bigquery_client):
+    return mock_bigquery_client.load_table_from_dataframe
+
+
+def test_to_gbq_create_dataset_with_location(mock_bigquery_client):
+    mock_bigquery_client.get_table.side_effect = google.api_core.exceptions.NotFound(
+        "my_table"
+    )
+    mock_bigquery_client.get_dataset.side_effect = google.api_core.exceptions.NotFound(
+        "my_dataset"
+    )
+    gbq.to_gbq(
+        DataFrame([[1]]), "my_dataset.my_table", project_id="1234", location="us-west1"
+    )
+    assert mock_bigquery_client.create_dataset.called
+    args, _ = mock_bigquery_client.create_dataset.call_args
+    sent_dataset = args[0]
+    assert sent_dataset.location == "us-west1"
+
+
+def test_to_gbq_create_dataset_translates_exception(mock_bigquery_client):
+    mock_bigquery_client.get_table.side_effect = google.api_core.exceptions.NotFound(
+        "my_table"
+    )
+    mock_bigquery_client.get_dataset.side_effect = google.api_core.exceptions.NotFound(
+        "my_dataset"
+    )
+    mock_bigquery_client.create_dataset.side_effect = (
+        google.api_core.exceptions.InternalServerError("something went wrong")
+    )
+
+    with pytest.raises(gbq.GenericGBQException):
+        gbq.to_gbq(DataFrame([[1]]), "my_dataset.my_table", project_id="1234")
+
+
+def test_to_gbq_load_method_translates_exception(
+    mock_bigquery_client, expected_load_method
+):
+    mock_bigquery_client.get_table.side_effect = google.api_core.exceptions.NotFound(
+        "my_table"
+    )
+    expected_load_method.side_effect = google.api_core.exceptions.InternalServerError(
+        "error loading data"
+    )
+
+    with pytest.raises(gbq.GenericGBQException):
+        gbq.to_gbq(
+            DataFrame({"int_cole": [1, 2, 3]}),
+            "my_dataset.my_table",
+            project_id="myproj",
+        )
+    expected_load_method.assert_called_once()
+
+
+def test_to_gbq_with_bigframes_raises_typeerror():
+    dataframe = FakeDataFrame()
+
+    with pytest.raises(
+        TypeError, match=r"Expected a pandas.DataFrame, but got .+FakeDataFrame"
+    ):
+        gbq.to_gbq(dataframe, "my_dataset.my_table", project_id="myproj")
+
+
+def test_to_gbq_with_if_exists_append(mock_bigquery_client, expected_load_method):
+    from google.cloud.bigquery import SchemaField
+
+    mock_bigquery_client.get_table.return_value = google.cloud.bigquery.Table(
+        "myproj.my_dataset.my_table",
+        schema=(
+            SchemaField("col_a", "FLOAT", mode="REQUIRED"),
+            SchemaField("col_b", "STRING", mode="REQUIRED"),
+        ),
+    )
+    gbq.to_gbq(
+        DataFrame({"col_a": [0.25, 1.5, -1.0], "col_b": ["a", "b", "c"]}),
+        "my_dataset.my_table",
+        project_id="myproj",
+        if_exists="append",
+    )
+    expected_load_method.assert_called_once()
+
+
+def test_to_gbq_with_if_exists_append_mismatch(mock_bigquery_client):
+    from google.cloud.bigquery import SchemaField
+
+    mock_bigquery_client.get_table.return_value = google.cloud.bigquery.Table(
+        "myproj.my_dataset.my_table",
+        schema=(SchemaField("col_a", "INTEGER"), SchemaField("col_b", "STRING")),
+    )
+    mock_bigquery_client.side_effect = gbq.InvalidSchema(
+        message=r"Provided Schema does not match Table *"
+    )
+
+    with pytest.raises((gbq.InvalidSchema)) as exception_block:
+        gbq.to_gbq(
+            DataFrame({"col_a": [0.25, 1.5, -1.0]}),
+            "my_dataset.my_table",
+            project_id="myproj",
+            if_exists="append",
+        )
+
+    exc = exception_block.value
+    assert exc.message == r"Provided Schema does not match Table *"
+
+
+def test_to_gbq_with_if_exists_replace(mock_bigquery_client, expected_load_method):
+    mock_bigquery_client.get_table.side_effect = (
+        # Initial check
+        google.cloud.bigquery.Table("myproj.my_dataset.my_table"),
+        # Recreate check
+        google.api_core.exceptions.NotFound("my_table"),
+    )
+    gbq.to_gbq(
+        DataFrame([[1]]),
+        "my_dataset.my_table",
+        project_id="myproj",
+        if_exists="replace",
+    )
+    expected_load_method.assert_called_once()
+
+
+def test_to_gbq_with_if_exists_replace_cross_project(
+    mock_bigquery_client, expected_load_method
+):
+    mock_bigquery_client.get_table.side_effect = (
+        # Initial check
+        google.cloud.bigquery.Table("data-project.my_dataset.my_table"),
+        # Recreate check
+        google.api_core.exceptions.NotFound("my_table"),
+    )
+    gbq.to_gbq(
+        DataFrame([[1]]),
+        "data-project.my_dataset.my_table",
+        project_id="billing-project",
+        if_exists="replace",
+    )
+    expected_load_method.assert_called_once()
+
+    # Check that billing project and destination table is set correctly.
+    expected_load_method.assert_called_once()
+    load_args, load_kwargs = expected_load_method.call_args
+    table_destination = load_args[1]
+    assert table_destination.project == "data-project"
+    assert table_destination.dataset_id == "my_dataset"
+    assert table_destination.table_id == "my_table"
+    assert load_kwargs["project"] == "billing-project"
+
+
+def test_to_gbq_with_if_exists_unknown():
+    with pytest.raises(ValueError):
+        gbq.to_gbq(
+            DataFrame([[1]]),
+            "my_dataset.my_table",
+            project_id="myproj",
+            if_exists="unknown",
+        )
+
+
+@pytest.mark.parametrize(
+    "user_agent,rfc9110_delimiter,expected",
+    [
+        (
+            "test_user_agent/2.0.42",
+            False,
+            f"test_user_agent/2.0.42 pandas-{pd.__version__}",
+        ),
+        (None, False, f"pandas-{pd.__version__}"),
+        (
+            "test_user_agent/2.0.42",
+            True,
+            f"test_user_agent/2.0.42 pandas/{pd.__version__}",
+        ),
+        (None, True, f"pandas/{pd.__version__}"),
+    ],
+)
+def test_create_user_agent(user_agent, rfc9110_delimiter, expected):
+    from pandas_gbq.gbq_connector import create_user_agent
+
+    result = create_user_agent(user_agent, rfc9110_delimiter)
+    assert result == expected
+
+
+@mock.patch.dict(os.environ, {"VSCODE_PID": "1234"}, clear=True)
+def test_create_user_agent_vscode():
+    from pandas_gbq.gbq_connector import create_user_agent
+
+    assert create_user_agent() == f"pandas-{pd.__version__} vscode"
+
+
+@mock.patch.dict(os.environ, {"VSCODE_PID": "1234"}, clear=True)
+def test_create_user_agent_vscode_plugin():
+    from pandas_gbq.gbq_connector import create_user_agent
+
+    with tempfile.TemporaryDirectory() as tmpdir:
+        user_home = Path(tmpdir)
+        plugin_dir = (
+            user_home / ".vscode" / "extensions" / "googlecloudtools.cloudcode-0.12"
+        )
+        plugin_config = plugin_dir / "package.json"
+
+        # originally pluging config does not exist
+        assert not plugin_config.exists()
+
+        # simulate plugin installation by creating plugin config on disk
+        plugin_dir.mkdir(parents=True)
+        with open(plugin_config, "w") as f:
+            f.write("{}")
+
+        with mock.patch("pathlib.Path.home", return_value=user_home):
+            assert (
+                create_user_agent()
+                == f"pandas-{pd.__version__} vscode googlecloudtools.cloudcode"
+            )
+
+
+@mock.patch.dict(os.environ, {"JPY_PARENT_PID": "1234"}, clear=True)
+def test_create_user_agent_jupyter():
+    from pandas_gbq.gbq_connector import create_user_agent
+
+    assert create_user_agent() == f"pandas-{pd.__version__} jupyter"
+
+
+@mock.patch.dict(os.environ, {"JPY_PARENT_PID": "1234"}, clear=True)
+def test_create_user_agent_jupyter_extension():
+    from pandas_gbq.gbq_connector import create_user_agent
+
+    def custom_import_module_side_effect(name, package=None):
+        if name == "bigquery_jupyter_plugin":
+            return mock.MagicMock()
+        else:
+            import importlib
+
+            return importlib.import_module(name, package)
+
+    with mock.patch(
+        "importlib.import_module", side_effect=custom_import_module_side_effect
+    ):
+        assert (
+            create_user_agent()
+            == f"pandas-{pd.__version__} jupyter bigquery_jupyter_plugin"
+        )
+
+
+def test_to_gbq_with_clustering(mock_bigquery_client):
+    mock_bigquery_client.get_table.side_effect = google.api_core.exceptions.NotFound(
+        "my_table"
+    )
+    gbq.to_gbq(
+        DataFrame([[1]]),
+        "my_dataset.my_table",
+        project_id="1234",
+        clustering_columns=["col_a", "col_b"],
+    )
+    mock_bigquery_client.create_table.assert_called_with(mock.ANY)
+    table = mock_bigquery_client.create_table.call_args[0][0]
+    assert table.clustering_fields == ["col_a", "col_b"]
+
+
+def test_to_gbq_with_time_partitioning(mock_bigquery_client):
+    mock_bigquery_client.get_table.side_effect = google.api_core.exceptions.NotFound(
+        "my_table"
+    )
+    gbq.to_gbq(
+        DataFrame([[1]]),
+        "my_dataset.my_table",
+        project_id="1234",
+        time_partitioning_column="time_col",
+        time_partitioning_type="DAY",
+        time_partitioning_expiration_ms=100,
+    )
+    mock_bigquery_client.create_table.assert_called_with(mock.ANY)
+    table = mock_bigquery_client.create_table.call_args[0][0]
+    assert table.time_partitioning.type_ == "DAY"
+    assert table.time_partitioning.field == "time_col"
+    assert table.time_partitioning.expiration_ms == 100
+
+
+def test_to_gbq_with_range_partitioning(mock_bigquery_client):
+    mock_bigquery_client.get_table.side_effect = google.api_core.exceptions.NotFound(
+        "my_table"
+    )
+    gbq.to_gbq(
+        DataFrame([[1]]),
+        "my_dataset.my_table",
+        project_id="1234",
+        range_partitioning_column="range_col",
+        range_partitioning_range={"start": 0, "end": 100, "interval": 10},
+    )
+    mock_bigquery_client.create_table.assert_called_with(mock.ANY)
+    table = mock_bigquery_client.create_table.call_args[0][0]
+    assert table.range_partitioning.field == "range_col"
+    assert table.range_partitioning.range_.start == 0
+    assert table.range_partitioning.range_.end == 100
+    assert table.range_partitioning.range_.interval == 10