diff --git a/ci/requirements-3.7-0.24.2.conda b/ci/requirements-3.7-0.24.2.conda
index e0323d92..a99bd59e 100644
--- a/ci/requirements-3.7-0.24.2.conda
+++ b/ci/requirements-3.7-0.24.2.conda
@@ -4,7 +4,8 @@ db-dtypes==0.3.1
 fastavro
 flake8
 numpy==1.16.6
-google-cloud-bigquery==1.11.1
+google-cloud-bigquery==1.27.2
+google-cloud-bigquery-storage==1.1.0
 pyarrow==3.0.0
 pydata-google-auth
 pytest
diff --git a/pandas_gbq/features.py b/pandas_gbq/features.py
index 4259eaf1..77535041 100644
--- a/pandas_gbq/features.py
+++ b/pandas_gbq/features.py
@@ -8,7 +8,10 @@
 BIGQUERY_MINIMUM_VERSION = "1.11.1"
 BIGQUERY_CLIENT_INFO_VERSION = "1.12.0"
 BIGQUERY_BQSTORAGE_VERSION = "1.24.0"
+BIGQUERY_ACCURATE_TIMESTAMP_VERSION = "2.6.0"
 BIGQUERY_FROM_DATAFRAME_CSV_VERSION = "2.6.0"
+BIGQUERY_SUPPORTS_BIGNUMERIC_VERSION = "2.10.0"
+BIGQUERY_NO_DATE_AS_OBJECT_VERSION = "3.0.0dev"
 PANDAS_VERBOSITY_DEPRECATION_VERSION = "0.23.0"
 PANDAS_BOOLEAN_DTYPE_VERSION = "1.0.0"
 PANDAS_PARQUET_LOSSLESS_TIMESTAMP_VERSION = "1.1.0"
@@ -42,6 +45,13 @@ def bigquery_installed_version(self):
 
         return self._bigquery_installed_version
 
+    @property
+    def bigquery_has_accurate_timestamp(self):
+        import pkg_resources
+
+        min_version = pkg_resources.parse_version(BIGQUERY_ACCURATE_TIMESTAMP_VERSION)
+        return self.bigquery_installed_version >= min_version
+
     @property
     def bigquery_has_client_info(self):
         import pkg_resources
@@ -51,6 +61,13 @@ def bigquery_has_client_info(self):
         )
         return self.bigquery_installed_version >= bigquery_client_info_version
 
+    @property
+    def bigquery_has_bignumeric(self):
+        import pkg_resources
+
+        min_version = pkg_resources.parse_version(BIGQUERY_SUPPORTS_BIGNUMERIC_VERSION)
+        return self.bigquery_installed_version >= min_version
+
     @property
     def bigquery_has_bqstorage(self):
         import pkg_resources
@@ -69,6 +86,13 @@ def bigquery_has_from_dataframe_with_csv(self):
         )
         return self.bigquery_installed_version >= bigquery_from_dataframe_version
 
+    @property
+    def bigquery_needs_date_as_object(self):
+        import pkg_resources
+
+        max_version = pkg_resources.parse_version(BIGQUERY_NO_DATE_AS_OBJECT_VERSION)
+        return self.bigquery_installed_version < max_version
+
     @property
     def pandas_installed_version(self):
         import pandas
diff --git a/pandas_gbq/gbq.py b/pandas_gbq/gbq.py
index 0a18cc3a..feca5e2a 100644
--- a/pandas_gbq/gbq.py
+++ b/pandas_gbq/gbq.py
@@ -2,13 +2,13 @@
 # Use of this source code is governed by a BSD-style
 # license that can be found in the LICENSE file.
 
+from datetime import datetime
 import logging
 import re
 import time
-import warnings
-from datetime import datetime
 import typing
-from typing import Any, Dict, Optional, Union
+from typing import Any, Dict, Optional, Sequence, Union
+import warnings
 
 import numpy as np
 
@@ -37,14 +37,13 @@
 import pandas_gbq.schema
 import pandas_gbq.timestamp
 
-
-logger = logging.getLogger(__name__)
-
 try:
     import tqdm  # noqa
 except ImportError:
     tqdm = None
 
+logger = logging.getLogger(__name__)
+
 
 def _test_google_api_imports():
     try:
@@ -52,6 +51,11 @@ def _test_google_api_imports():
     except ImportError as ex:
         raise ImportError("pandas-gbq requires setuptools") from ex
 
+    try:
+        import db_dtypes  # noqa
+    except ImportError as ex:
+        raise ImportError("pandas-gbq requires db-dtypes") from ex
+
     try:
         import pydata_google_auth  # noqa
     except ImportError as ex:
@@ -546,6 +550,8 @@ def _download_results(
         to_dataframe_kwargs = {}
         if FEATURES.bigquery_has_bqstorage:
             to_dataframe_kwargs["create_bqstorage_client"] = create_bqstorage_client
+        if FEATURES.bigquery_needs_date_as_object:
+            to_dataframe_kwargs["date_as_object"] = True
 
         try:
             schema_fields = [field.to_api_repr() for field in rows_iter.schema]
@@ -559,11 +565,7 @@ def _download_results(
         except self.http_error as ex:
             self.process_http_error(ex)
 
-        if df.empty:
-            df = _cast_empty_df_dtypes(schema_fields, df)
-
-        # Ensure any TIMESTAMP columns are tz-aware.
-        df = pandas_gbq.timestamp.localize_df(df, schema_fields)
+        df = _finalize_dtypes(df, schema_fields)
 
         logger.debug("Got {} rows.\n".format(rows_iter.total_rows))
         return df
@@ -617,23 +619,18 @@ def _bqschema_to_nullsafe_dtypes(schema_fields):
     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 = {
-        "DATE": "datetime64[ns]",
-        "DATETIME": "datetime64[ns]",
         "FLOAT": np.dtype(float),
-        "GEOMETRY": "object",
         "INTEGER": "Int64",
-        "RECORD": "object",
-        "STRING": "object",
-        # datetime.time objects cannot be case to datetime64.
-        # https://github.com/pydata/pandas-gbq/issues/328
-        "TIME": "object",
-        # pandas doesn't support timezone-aware dtype in DataFrame/Series
-        # constructors. It's more idiomatic to localize after construction.
-        # https://github.com/pandas-dev/pandas/issues/25843
-        "TIMESTAMP": "datetime64[ns]",
+        "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.
@@ -656,28 +653,43 @@ def _bqschema_to_nullsafe_dtypes(schema_fields):
     return dtypes
 
 
-def _cast_empty_df_dtypes(schema_fields, df):
-    """Cast any columns in an empty dataframe to correct type.
+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.
 
-    In an empty dataframe, pandas cannot choose a dtype unless one is
-    explicitly provided. The _bqschema_to_nullsafe_dtypes() function only
-    provides dtypes when the dtype safely handles null values. This means
-    that empty int64 and boolean columns are incorrectly classified as
-    ``object``.
+    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
     """
-    if not df.empty:
-        raise ValueError("DataFrame must be empty in order to cast non-nullsafe dtypes")
+    import db_dtypes
+    import pandas.api.types
 
-    dtype_map = {"BOOLEAN": bool, "INTEGER": np.int64}
+    # 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:
-        column = str(field["name"])
+        # 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())
-        if dtype:
-            df[column] = df[column].astype(dtype)
+
+        # 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
 
diff --git a/pandas_gbq/timestamp.py b/pandas_gbq/timestamp.py
index c6bb6d93..66374881 100644
--- a/pandas_gbq/timestamp.py
+++ b/pandas_gbq/timestamp.py
@@ -30,11 +30,6 @@ def localize_df(df, schema_fields):
     pandas.DataFrame
         DataFrame with localized TIMESTAMP columns.
     """
-    if len(df.index) == 0:
-        # If there are no rows, there is nothing to do.
-        # Fix for https://github.com/pydata/pandas-gbq/issues/299
-        return df
-
     for field in schema_fields:
         column = str(field["name"])
         if "mode" in field and field["mode"].upper() == "REPEATED":
diff --git a/setup.py b/setup.py
index 2e596cc6..ccee7265 100644
--- a/setup.py
+++ b/setup.py
@@ -28,12 +28,19 @@
     "pandas >=0.24.2",
     "pyarrow >=3.0.0, <7.0dev",
     "pydata-google-auth",
-    "google-api-core >=1.14.0",
-    "google-auth >=1.4.1",
+    # 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 >=1.21.0",
+    "google-auth >=1.18.0",
     "google-auth-oauthlib >=0.0.1",
-    # 2.4.* has a bug where waiting for the query can hang indefinitely.
-    # https://github.com/pydata/pandas-gbq/issues/343
-    "google-cloud-bigquery[bqstorage,pandas] >=1.11.1,<4.0.0dev,!=2.4.*",
+    # Require 1.27.* because it has a fix for out-of-bounds timestamps.  See:
+    # https://github.com/googleapis/python-bigquery/pull/209 and
+    # https://github.com/googleapis/python-bigquery-pandas/issues/365
+    # Exclude 2.4.* because it has a bug where waiting for the query can hang
+    # indefinitely. https://github.com/pydata/pandas-gbq/issues/343
+    "google-cloud-bigquery >=1.27.2,<4.0.0dev,!=2.4.*",
+    "google-cloud-bigquery-storage >=1.1.0,<3.0.0dev",
 ]
 extras = {
     "tqdm": "tqdm>=4.23.0",
diff --git a/testing/constraints-3.7.txt b/testing/constraints-3.7.txt
index 2a500f35..f0c9a4ac 100644
--- a/testing/constraints-3.7.txt
+++ b/testing/constraints-3.7.txt
@@ -6,10 +6,10 @@
 # e.g., if setup.py has "foo >= 1.14.0, < 2.0.0dev",
 # Then this file should have foo==1.14.0
 db-dtypes==0.3.1
-google-api-core==1.14.0
-google-auth==1.4.1
+google-api-core==1.21.0
+google-auth==1.18.0
 google-auth-oauthlib==0.0.1
-google-cloud-bigquery==1.11.1
+google-cloud-bigquery==1.27.2
 google-cloud-bigquery-storage==1.1.0
 numpy==1.16.6
 pandas==0.24.2
diff --git a/tests/system/test_gbq.py b/tests/system/test_gbq.py
index 67735c53..ec588a3e 100644
--- a/tests/system/test_gbq.py
+++ b/tests/system/test_gbq.py
@@ -11,7 +11,7 @@
 import pandas
 import pandas.api.types
 import pandas.testing as tm
-from pandas import DataFrame, NaT
+from pandas import DataFrame
 
 try:
     import pkg_resources  # noqa
@@ -21,7 +21,6 @@
 import pytz
 
 from pandas_gbq import gbq
-from pandas_gbq.features import FEATURES
 import pandas_gbq.schema
 
 
@@ -153,319 +152,6 @@ def setup(self, project, credentials):
         self.gbq_connector = gbq.GbqConnector(project, credentials=credentials)
         self.credentials = credentials
 
-    def test_should_properly_handle_empty_strings(self, project_id):
-        query = 'SELECT "" AS empty_string'
-        df = gbq.read_gbq(
-            query,
-            project_id=project_id,
-            credentials=self.credentials,
-            dialect="legacy",
-        )
-        tm.assert_frame_equal(df, DataFrame({"empty_string": [""]}))
-
-    def test_should_properly_handle_null_strings(self, project_id):
-        query = "SELECT STRING(NULL) AS null_string"
-        df = gbq.read_gbq(
-            query,
-            project_id=project_id,
-            credentials=self.credentials,
-            dialect="legacy",
-        )
-        tm.assert_frame_equal(df, DataFrame({"null_string": [None]}))
-
-    def test_should_properly_handle_valid_integers(self, project_id):
-        query = "SELECT CAST(3 AS INT64) AS valid_integer"
-        df = gbq.read_gbq(
-            query,
-            project_id=project_id,
-            credentials=self.credentials,
-            dialect="standard",
-        )
-        tm.assert_frame_equal(df, DataFrame({"valid_integer": [3]}, dtype="Int64"))
-
-    def test_should_properly_handle_nullable_integers(self, project_id):
-        query = """SELECT * FROM
-                    UNNEST([1, NULL]) AS nullable_integer
-                """
-        df = gbq.read_gbq(
-            query,
-            project_id=project_id,
-            credentials=self.credentials,
-            dialect="standard",
-            dtypes={"nullable_integer": "Int64"},
-        )
-        tm.assert_frame_equal(
-            df,
-            DataFrame({"nullable_integer": pandas.Series([1, None], dtype="Int64")}),
-        )
-
-    def test_should_properly_handle_valid_longs(self, project_id):
-        query = "SELECT 1 << 62 AS valid_long"
-        df = gbq.read_gbq(
-            query,
-            project_id=project_id,
-            credentials=self.credentials,
-            dialect="standard",
-        )
-        tm.assert_frame_equal(df, DataFrame({"valid_long": [1 << 62]}, dtype="Int64"))
-
-    def test_should_properly_handle_nullable_longs(self, project_id):
-        query = """SELECT * FROM
-                    UNNEST([1 << 62, NULL]) AS nullable_long
-                """
-        df = gbq.read_gbq(
-            query,
-            project_id=project_id,
-            credentials=self.credentials,
-            dialect="standard",
-            dtypes={"nullable_long": "Int64"},
-        )
-        tm.assert_frame_equal(
-            df,
-            DataFrame({"nullable_long": pandas.Series([1 << 62, None], dtype="Int64")}),
-        )
-
-    def test_should_properly_handle_null_integers(self, project_id):
-        query = "SELECT CAST(NULL AS INT64) AS null_integer"
-        df = gbq.read_gbq(
-            query,
-            project_id=project_id,
-            credentials=self.credentials,
-            dialect="standard",
-            dtypes={"null_integer": "Int64"},
-        )
-        tm.assert_frame_equal(
-            df, DataFrame({"null_integer": pandas.Series([None], dtype="Int64")}),
-        )
-
-    def test_should_properly_handle_valid_floats(self, project_id):
-        from math import pi
-
-        query = "SELECT PI() AS valid_float"
-        df = gbq.read_gbq(
-            query,
-            project_id=project_id,
-            credentials=self.credentials,
-            dialect="legacy",
-        )
-        tm.assert_frame_equal(df, DataFrame({"valid_float": [pi]}))
-
-    def test_should_properly_handle_nullable_floats(self, project_id):
-        from math import pi
-
-        query = """SELECT * FROM
-                    (SELECT PI() AS nullable_float),
-                    (SELECT NULL AS nullable_float)"""
-        df = gbq.read_gbq(
-            query,
-            project_id=project_id,
-            credentials=self.credentials,
-            dialect="legacy",
-        )
-        tm.assert_frame_equal(df, DataFrame({"nullable_float": [pi, None]}))
-
-    def test_should_properly_handle_valid_doubles(self, project_id):
-        from math import pi
-
-        query = "SELECT PI() * POW(10, 307) AS valid_double"
-        df = gbq.read_gbq(
-            query,
-            project_id=project_id,
-            credentials=self.credentials,
-            dialect="legacy",
-        )
-        tm.assert_frame_equal(df, DataFrame({"valid_double": [pi * 10 ** 307]}))
-
-    def test_should_properly_handle_nullable_doubles(self, project_id):
-        from math import pi
-
-        query = """SELECT * FROM
-                    (SELECT PI() * POW(10, 307) AS nullable_double),
-                    (SELECT NULL AS nullable_double)"""
-        df = gbq.read_gbq(
-            query,
-            project_id=project_id,
-            credentials=self.credentials,
-            dialect="legacy",
-        )
-        tm.assert_frame_equal(
-            df, DataFrame({"nullable_double": [pi * 10 ** 307, None]})
-        )
-
-    def test_should_properly_handle_null_floats(self, project_id):
-        query = """SELECT null_float
-        FROM UNNEST(ARRAY<FLOAT64>[NULL, 1.0]) AS null_float
-        """
-        df = gbq.read_gbq(
-            query,
-            project_id=project_id,
-            credentials=self.credentials,
-            dialect="standard",
-        )
-        tm.assert_frame_equal(df, DataFrame({"null_float": [np.nan, 1.0]}))
-
-    def test_should_properly_handle_date(self, project_id):
-        query = "SELECT DATE(2003, 1, 4) AS date_col"
-        df = gbq.read_gbq(query, project_id=project_id, credentials=self.credentials,)
-        expected = DataFrame(
-            {
-                "date_col": pandas.Series(
-                    [datetime.date(2003, 1, 4)], dtype="datetime64[ns]"
-                )
-            },
-        )
-        tm.assert_frame_equal(df, expected)
-
-    def test_should_properly_handle_time(self, project_id):
-        query = (
-            "SELECT TIME_ADD(TIME(3, 14, 15), INTERVAL 926589 MICROSECOND) AS time_col"
-        )
-        df = gbq.read_gbq(query, project_id=project_id, credentials=self.credentials,)
-        expected = DataFrame(
-            {
-                "time_col": pandas.Series(
-                    [datetime.time(3, 14, 15, 926589)], dtype="object"
-                )
-            },
-        )
-        tm.assert_frame_equal(df, expected)
-
-    def test_should_properly_handle_timestamp_unix_epoch(self, project_id):
-        query = 'SELECT TIMESTAMP("1970-01-01 00:00:00") AS unix_epoch'
-        df = gbq.read_gbq(
-            query,
-            project_id=project_id,
-            credentials=self.credentials,
-            dialect="legacy",
-        )
-        expected = DataFrame(
-            {"unix_epoch": ["1970-01-01T00:00:00.000000Z"]}, dtype="datetime64[ns]",
-        )
-        if expected["unix_epoch"].dt.tz is None:
-            expected["unix_epoch"] = expected["unix_epoch"].dt.tz_localize("UTC")
-        tm.assert_frame_equal(df, expected)
-
-    def test_should_properly_handle_arbitrary_timestamp(self, project_id):
-        query = 'SELECT TIMESTAMP("2004-09-15 05:00:00") AS valid_timestamp'
-        df = gbq.read_gbq(
-            query,
-            project_id=project_id,
-            credentials=self.credentials,
-            dialect="legacy",
-        )
-        expected = DataFrame(
-            {"valid_timestamp": ["2004-09-15T05:00:00.000000Z"]},
-            dtype="datetime64[ns]",
-        )
-        if expected["valid_timestamp"].dt.tz is None:
-            expected["valid_timestamp"] = expected["valid_timestamp"].dt.tz_localize(
-                "UTC"
-            )
-        tm.assert_frame_equal(df, expected)
-
-    def test_should_properly_handle_datetime_unix_epoch(self, project_id):
-        query = 'SELECT DATETIME("1970-01-01 00:00:00") AS unix_epoch'
-        df = gbq.read_gbq(
-            query,
-            project_id=project_id,
-            credentials=self.credentials,
-            dialect="legacy",
-        )
-        tm.assert_frame_equal(
-            df,
-            DataFrame({"unix_epoch": ["1970-01-01T00:00:00"]}, dtype="datetime64[ns]"),
-        )
-
-    def test_should_properly_handle_arbitrary_datetime(self, project_id):
-        query = 'SELECT DATETIME("2004-09-15 05:00:00") AS valid_timestamp'
-        df = gbq.read_gbq(
-            query,
-            project_id=project_id,
-            credentials=self.credentials,
-            dialect="legacy",
-        )
-        tm.assert_frame_equal(
-            df, DataFrame({"valid_timestamp": [np.datetime64("2004-09-15T05:00:00")]}),
-        )
-
-    @pytest.mark.parametrize(
-        "expression, is_expected_dtype",
-        [
-            ("current_date()", pandas.api.types.is_datetime64_ns_dtype),
-            ("current_timestamp()", pandas.api.types.is_datetime64tz_dtype),
-            ("current_datetime()", pandas.api.types.is_datetime64_ns_dtype),
-            ("TRUE", pandas.api.types.is_bool_dtype),
-            ("FALSE", pandas.api.types.is_bool_dtype),
-        ],
-    )
-    def test_return_correct_types(self, project_id, expression, is_expected_dtype):
-        """
-        All type checks can be added to this function using additional
-        parameters, rather than creating additional functions.
-        We can consolidate the existing functions here in time
-
-        TODO: time doesn't currently parse
-        ("time(12,30,00)", "<M8[ns]"),
-        """
-        query = "SELECT {} AS _".format(expression)
-        df = gbq.read_gbq(
-            query,
-            project_id=project_id,
-            credentials=self.credentials,
-            dialect="standard",
-        )
-        assert is_expected_dtype(df["_"].dtype)
-
-    def test_should_properly_handle_null_timestamp(self, project_id):
-        query = "SELECT TIMESTAMP(NULL) AS null_timestamp"
-        df = gbq.read_gbq(
-            query,
-            project_id=project_id,
-            credentials=self.credentials,
-            dialect="legacy",
-        )
-        expected = DataFrame({"null_timestamp": [NaT]}, dtype="datetime64[ns]")
-        expected["null_timestamp"] = expected["null_timestamp"].dt.tz_localize("UTC")
-        tm.assert_frame_equal(df, expected)
-
-    def test_should_properly_handle_null_datetime(self, project_id):
-        query = "SELECT CAST(NULL AS DATETIME) AS null_datetime"
-        df = gbq.read_gbq(
-            query,
-            project_id=project_id,
-            credentials=self.credentials,
-            dialect="standard",
-        )
-        tm.assert_frame_equal(df, DataFrame({"null_datetime": [NaT]}))
-
-    def test_should_properly_handle_null_boolean(self, project_id):
-        query = "SELECT BOOLEAN(NULL) AS null_boolean"
-        df = gbq.read_gbq(
-            query,
-            project_id=project_id,
-            credentials=self.credentials,
-            dialect="legacy",
-        )
-        expected_dtype = "boolean" if FEATURES.pandas_has_boolean_dtype else None
-        tm.assert_frame_equal(
-            df, DataFrame({"null_boolean": [None]}, dtype=expected_dtype)
-        )
-
-    def test_should_properly_handle_nullable_booleans(self, project_id):
-        query = """SELECT * FROM
-                    (SELECT BOOLEAN(TRUE) AS nullable_boolean),
-                    (SELECT NULL AS nullable_boolean)"""
-        df = gbq.read_gbq(
-            query,
-            project_id=project_id,
-            credentials=self.credentials,
-            dialect="legacy",
-        )
-        expected_dtype = "boolean" if FEATURES.pandas_has_boolean_dtype else None
-        tm.assert_frame_equal(
-            df, DataFrame({"nullable_boolean": [True, None]}, dtype=expected_dtype)
-        )
-
     def test_unicode_string_conversion_and_normalization(self, project_id):
         correct_test_datatype = DataFrame({"unicode_string": ["éü"]})
         unicode_string = "éü"
@@ -619,26 +305,6 @@ def test_max_results(self, random_dataset, project_id):
         )
         assert len(df) == 10
 
-    def test_zero_rows(self, project_id):
-        # Bug fix for https://github.com/pandas-dev/pandas/issues/10273
-        df = gbq.read_gbq(
-            'SELECT name, number, (mlc_class = "HU") is_hurricane, iso_time '
-            "FROM `bigquery-public-data.noaa_hurricanes.hurricanes` "
-            'WHERE iso_time = TIMESTAMP("1900-01-01 00:00:00") ',
-            project_id=project_id,
-            credentials=self.credentials,
-        )
-        empty_columns = {
-            "name": pandas.Series([], dtype=object),
-            "number": pandas.Series([], dtype=np.dtype(int)),
-            "is_hurricane": pandas.Series([], dtype=np.dtype(bool)),
-            "iso_time": pandas.Series([], dtype="datetime64[ns]"),
-        }
-        expected_result = DataFrame(
-            empty_columns, columns=["name", "number", "is_hurricane", "iso_time"],
-        )
-        tm.assert_frame_equal(df, expected_result, check_index_type=False)
-
     def test_one_row_one_column(self, project_id):
         df = gbq.read_gbq(
             "SELECT 3 as v",
diff --git a/tests/system/test_read_gbq.py b/tests/system/test_read_gbq.py
new file mode 100644
index 00000000..a13e830f
--- /dev/null
+++ b/tests/system/test_read_gbq.py
@@ -0,0 +1,607 @@
+# 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 db_dtypes
+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.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",
+            marks=pytest.mark.skipif(
+                not FEATURES.bigquery_has_bignumeric,
+                reason="BIGNUMERIC not supported in this version of google-cloud-bigquery",
+            ),
+        ),
+        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}
+                if FEATURES.bigquery_has_accurate_timestamp
+                else {True},
+            ),
+            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.")
+    result = read_gbq(query, use_bqstorage_api=use_bqstorage_api)
+    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)
diff --git a/tests/system/test_to_gbq.py b/tests/system/test_to_gbq.py
index a9274091..ae3b8614 100644
--- a/tests/system/test_to_gbq.py
+++ b/tests/system/test_to_gbq.py
@@ -160,7 +160,12 @@ def test_series_round_trip(
             columns=["row_num", "date_col"],
         ),
         expected_df=pandas.DataFrame(
-            {"row_num": [123], "date_col": [datetime.date(2021, 12, 12)]},
+            {
+                "row_num": [123],
+                "date_col": pandas.Series(
+                    [datetime.date(2021, 12, 12)], dtype=db_dtypes.DateDtype()
+                ),
+            },
             columns=["row_num", "date_col"],
         ),
         table_schema=[
@@ -196,29 +201,29 @@ def test_series_round_trip(
                         datetime.date(1970, 1, 1),
                         datetime.date(9999, 12, 31),
                     ],
-                    # TODO: DATETIME/TIMESTAMP values outside of the range for
-                    # pandas timestamp require `date_as_object` parameter in
-                    # google-cloud-bigquery versions 1.x and 2.x.
+                    # 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,
-                    #     ),
-                    # ],
+                    "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"],
             ),
@@ -256,7 +261,12 @@ def test_dataframe_round_trip_with_table_schema(
         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)),
+        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,
     )
     round_trip.sort_values("row_num", inplace=True)
     pandas.testing.assert_frame_equal(expected_df, round_trip)
diff --git a/tests/unit/test_features.py b/tests/unit/test_features.py
index d62480f3..c810104f 100644
--- a/tests/unit/test_features.py
+++ b/tests/unit/test_features.py
@@ -13,6 +13,42 @@ def fresh_bigquery_version(monkeypatch):
     monkeypatch.setattr(FEATURES, "_pandas_installed_version", None)
 
 
+@pytest.mark.parametrize(
+    ["bigquery_version", "expected"],
+    [
+        ("1.11.1", False),
+        ("1.26.0", False),
+        ("2.5.4", False),
+        ("2.6.0", True),
+        ("2.6.1", True),
+        ("2.12.0", True),
+    ],
+)
+def test_bigquery_has_accurate_timestamp(monkeypatch, bigquery_version, expected):
+    import google.cloud.bigquery
+
+    monkeypatch.setattr(google.cloud.bigquery, "__version__", bigquery_version)
+    assert FEATURES.bigquery_has_accurate_timestamp == expected
+
+
+@pytest.mark.parametrize(
+    ["bigquery_version", "expected"],
+    [
+        ("1.11.1", False),
+        ("1.26.0", False),
+        ("2.9.999", False),
+        ("2.10.0", True),
+        ("2.12.0", True),
+        ("3.0.0", True),
+    ],
+)
+def test_bigquery_has_bignumeric(monkeypatch, bigquery_version, expected):
+    import google.cloud.bigquery
+
+    monkeypatch.setattr(google.cloud.bigquery, "__version__", bigquery_version)
+    assert FEATURES.bigquery_has_bignumeric == expected
+
+
 @pytest.mark.parametrize(
     ["bigquery_version", "expected"],
     [
@@ -31,6 +67,17 @@ def test_bigquery_has_from_dataframe_with_csv(monkeypatch, bigquery_version, exp
     assert FEATURES.bigquery_has_from_dataframe_with_csv == expected
 
 
+@pytest.mark.parametrize(
+    ["bigquery_version", "expected"],
+    [("1.26.0", True), ("2.12.0", True), ("3.0.0", False), ("3.1.0", False)],
+)
+def test_bigquery_needs_date_as_object(monkeypatch, bigquery_version, expected):
+    import google.cloud.bigquery
+
+    monkeypatch.setattr(google.cloud.bigquery, "__version__", bigquery_version)
+    assert FEATURES.bigquery_needs_date_as_object == expected
+
+
 @pytest.mark.parametrize(
     ["pandas_version", "expected"],
     [
diff --git a/tests/unit/test_gbq.py b/tests/unit/test_gbq.py
index 8740f618..9748595f 100644
--- a/tests/unit/test_gbq.py
+++ b/tests/unit/test_gbq.py
@@ -74,9 +74,10 @@ def get_table(table_ref_or_id, **kwargs):
         ("SOME_NEW_UNKNOWN_TYPE", None),
         ("INTEGER", "Int64"),
         ("FLOAT", numpy.dtype(float)),
-        # TIMESTAMP will be localized after DataFrame construction.
-        ("TIMESTAMP", "datetime64[ns]"),
-        ("DATETIME", "datetime64[ns]"),
+        # TIMESTAMP/DATETIME might require object dtype for out-of-bounds
+        # values.
+        ("TIMESTAMP", None),
+        ("DATETIME", None),
     ],
 )
 def test__bqschema_to_nullsafe_dtypes(type_, expected):
@@ -618,9 +619,17 @@ def test_read_gbq_use_bqstorage_api(
     assert df is not None
 
     mock_list_rows = mock_bigquery_client.list_rows("dest", max_results=100)
-    mock_list_rows.to_dataframe.assert_called_once_with(
-        create_bqstorage_client=True, dtypes=mock.ANY, progress_bar_type=mock.ANY,
-    )
+    if FEATURES.bigquery_needs_date_as_object:
+        mock_list_rows.to_dataframe.assert_called_once_with(
+            create_bqstorage_client=True,
+            dtypes=mock.ANY,
+            progress_bar_type=mock.ANY,
+            date_as_object=True,
+        )
+    else:
+        mock_list_rows.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_bigquery_client, mock_service_account_credentials):