google-cloud-bigquery 3.18.0__tar.gz → 3.19.0__tar.gz

{google-cloud-bigquery-3.18.0/google_cloud_bigquery.egg-info → google-cloud-bigquery-3.19.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: google-cloud-bigquery
-Version: 3.18.0
+Version: 3.19.0
 Summary: Google BigQuery API client library
 Home-page: https://github.com/googleapis/python-bigquery
 Author: Google LLC
@@ -22,7 +22,8 @@ Classifier: Operating System :: OS Independent
 Classifier: Topic :: Internet
 Requires-Python: >=3.7
 License-File: LICENSE
-Requires-Dist: google-api-core!=2.0.*,!=2.1.*,!=2.2.*,!=2.3.0,<3.0.0dev,>=1.31.5
+Requires-Dist: google-api-core[grpc]!=2.0.*,!=2.1.*,!=2.10.*,!=2.2.*,!=2.3.*,!=2.4.*,!=2.5.*,!=2.6.*,!=2.7.*,!=2.8.*,!=2.9.*,<3.0.0dev,>=1.34.1
+Requires-Dist: google-auth<3.0.0dev,>=2.14.1
 Requires-Dist: google-cloud-core<3.0.0dev,>=1.6.0
 Requires-Dist: google-resumable-media<3.0dev,>=0.6.0
 Requires-Dist: packaging>=20.0.0

{google-cloud-bigquery-3.18.0 → google-cloud-bigquery-3.19.0}/google/cloud/bigquery/__init__.py

@@ -83,6 +83,8 @@ from google.cloud.bigquery.query import ArrayQueryParameterType
 from google.cloud.bigquery.query import ConnectionProperty
 from google.cloud.bigquery.query import ScalarQueryParameter
 from google.cloud.bigquery.query import ScalarQueryParameterType
+from google.cloud.bigquery.query import RangeQueryParameter
+from google.cloud.bigquery.query import RangeQueryParameterType
 from google.cloud.bigquery.query import SqlParameterScalarTypes
 from google.cloud.bigquery.query import StructQueryParameter
 from google.cloud.bigquery.query import StructQueryParameterType
@@ -122,10 +124,12 @@ __all__ = [
     "ArrayQueryParameter",
     "ScalarQueryParameter",
     "StructQueryParameter",
+    "RangeQueryParameter",
     "ArrayQueryParameterType",
     "ScalarQueryParameterType",
     "SqlParameterScalarTypes",
     "StructQueryParameterType",
+    "RangeQueryParameterType",
     # Datasets
     "Dataset",
     "DatasetReference",

{google-cloud-bigquery-3.18.0 → google-cloud-bigquery-3.19.0}/google/cloud/bigquery/_helpers.py

@@ -30,6 +30,8 @@ from google.cloud._helpers import _datetime_from_microseconds
 from google.cloud._helpers import _RFC3339_MICROS
 from google.cloud._helpers import _RFC3339_NO_FRACTION
 from google.cloud._helpers import _to_bytes
+from google.auth import credentials as ga_credentials  # type: ignore
+from google.api_core import client_options as client_options_lib
 
 _RFC3339_MICROS_NO_ZULU = "%Y-%m-%dT%H:%M:%S.%f"
 _TIMEONLY_WO_MICROS = "%H:%M:%S"
@@ -55,9 +57,66 @@ BIGQUERY_EMULATOR_HOST = "BIGQUERY_EMULATOR_HOST"
 _DEFAULT_HOST = "https://bigquery.googleapis.com"
 """Default host for JSON API."""
 
+_DEFAULT_HOST_TEMPLATE = "https://bigquery.{UNIVERSE_DOMAIN}"
+""" Templatized endpoint format. """
+
 _DEFAULT_UNIVERSE = "googleapis.com"
 """Default universe for the JSON API."""
 
+_UNIVERSE_DOMAIN_ENV = "GOOGLE_CLOUD_UNIVERSE_DOMAIN"
+"""Environment variable for setting universe domain."""
+
+
+def _get_client_universe(
+    client_options: Optional[Union[client_options_lib.ClientOptions, dict]]
+) -> str:
+    """Retrieves the specified universe setting.
+
+    Args:
+        client_options: specified client options.
+    Returns:
+        str: resolved universe setting.
+
+    """
+    if isinstance(client_options, dict):
+        client_options = client_options_lib.from_dict(client_options)
+    universe = _DEFAULT_UNIVERSE
+    options_universe = getattr(client_options, "universe_domain", None)
+    if (
+        options_universe
+        and isinstance(options_universe, str)
+        and len(options_universe) > 0
+    ):
+        universe = options_universe
+    else:
+        env_universe = os.getenv(_UNIVERSE_DOMAIN_ENV)
+        if isinstance(env_universe, str) and len(env_universe) > 0:
+            universe = env_universe
+    return universe
+
+
+def _validate_universe(client_universe: str, credentials: ga_credentials.Credentials):
+    """Validates that client provided universe and universe embedded in credentials match.
+
+    Args:
+        client_universe (str): The universe domain configured via the client options.
+        credentials (ga_credentials.Credentials): The credentials being used in the client.
+
+    Raises:
+        ValueError: when client_universe does not match the universe in credentials.
+    """
+    if hasattr(credentials, "universe_domain"):
+        cred_universe = getattr(credentials, "universe_domain")
+        if isinstance(cred_universe, str):
+            if client_universe != cred_universe:
+                raise ValueError(
+                    "The configured universe domain "
+                    f"({client_universe}) does not match the universe domain "
+                    f"found in the credentials ({cred_universe}). "
+                    "If you haven't configured the universe domain explicitly, "
+                    f"`{_DEFAULT_UNIVERSE}` is the default."
+                )
+
 
 def _get_bigquery_host():
     return os.environ.get(BIGQUERY_EMULATOR_HOST, _DEFAULT_HOST)

{google-cloud-bigquery-3.18.0 → google-cloud-bigquery-3.19.0}/google/cloud/bigquery/client.py

@@ -78,7 +78,10 @@ from google.cloud.bigquery._helpers import _str_or_none
 from google.cloud.bigquery._helpers import _verify_job_config_type
 from google.cloud.bigquery._helpers import _get_bigquery_host
 from google.cloud.bigquery._helpers import _DEFAULT_HOST
+from google.cloud.bigquery._helpers import _DEFAULT_HOST_TEMPLATE
 from google.cloud.bigquery._helpers import _DEFAULT_UNIVERSE
+from google.cloud.bigquery._helpers import _validate_universe
+from google.cloud.bigquery._helpers import _get_client_universe
 from google.cloud.bigquery._job_helpers import make_job_id as _make_job_id
 from google.cloud.bigquery.dataset import Dataset
 from google.cloud.bigquery.dataset import DatasetListItem
@@ -245,22 +248,23 @@ class Client(ClientWithProject):
         kw_args = {"client_info": client_info}
         bq_host = _get_bigquery_host()
         kw_args["api_endpoint"] = bq_host if bq_host != _DEFAULT_HOST else None
-        if client_options:
-            if isinstance(client_options, dict):
-                client_options = google.api_core.client_options.from_dict(
-                    client_options
-                )
-            if client_options.api_endpoint:
-                api_endpoint = client_options.api_endpoint
-                kw_args["api_endpoint"] = api_endpoint
-            elif (
-                hasattr(client_options, "universe_domain")
-                and client_options.universe_domain
-                and client_options.universe_domain is not _DEFAULT_UNIVERSE
-            ):
-                kw_args["api_endpoint"] = _DEFAULT_HOST.replace(
-                    _DEFAULT_UNIVERSE, client_options.universe_domain
+        client_universe = None
+        if client_options is None:
+            client_options = {}
+        if isinstance(client_options, dict):
+            client_options = google.api_core.client_options.from_dict(client_options)
+        if client_options.api_endpoint:
+            api_endpoint = client_options.api_endpoint
+            kw_args["api_endpoint"] = api_endpoint
+        else:
+            client_universe = _get_client_universe(client_options)
+            if client_universe != _DEFAULT_UNIVERSE:
+                kw_args["api_endpoint"] = _DEFAULT_HOST_TEMPLATE.replace(
+                    "{UNIVERSE_DOMAIN}", client_universe
                 )
+        # Ensure credentials and universe are not in conflict.
+        if hasattr(self, "_credentials") and client_universe is not None:
+            _validate_universe(client_universe, self._credentials)
 
         self._connection = Connection(self, **kw_args)
         self._location = location

{google-cloud-bigquery-3.18.0 → google-cloud-bigquery-3.19.0}/google/cloud/bigquery/enums.py

@@ -254,6 +254,7 @@ class StandardSqlTypeNames(str, enum.Enum):
     JSON = enum.auto()
     ARRAY = enum.auto()
     STRUCT = enum.auto()
+    RANGE = enum.auto()
 
 
 class EntityTypes(str, enum.Enum):
@@ -292,6 +293,7 @@ class SqlTypeNames(str, enum.Enum):
     TIME = "TIME"
     DATETIME = "DATETIME"
     INTERVAL = "INTERVAL"  # NOTE: not available in legacy types
+    RANGE = "RANGE"  # NOTE: not available in legacy types
 
 
 class WriteDisposition(object):

{google-cloud-bigquery-3.18.0 → google-cloud-bigquery-3.19.0}/google/cloud/bigquery/query.py

@@ -30,6 +30,8 @@ _SCALAR_VALUE_TYPE = Optional[
     Union[str, int, float, decimal.Decimal, bool, datetime.datetime, datetime.date]
 ]
 
+_RANGE_ELEMENT_TYPE_STR = {"TIMESTAMP", "DATETIME", "DATE"}
+
 
 class ConnectionProperty:
     """A connection-level property to customize query behavior.
@@ -362,6 +364,129 @@ class StructQueryParameterType(_AbstractQueryParameterType):
         return f"{self.__class__.__name__}({items}{name}{description})"
 
 
+class RangeQueryParameterType(_AbstractQueryParameterType):
+    """Type representation for range query parameters.
+
+    Args:
+        type_ (Union[ScalarQueryParameterType, str]):
+            Type of range element, must be one of 'TIMESTAMP', 'DATETIME', or
+            'DATE'.
+        name (Optional[str]):
+            The name of the query parameter. Primarily used if the type is
+            one of the subfields in ``StructQueryParameterType`` instance.
+        description (Optional[str]):
+            The query parameter description. Primarily used if the type is
+            one of the subfields in ``StructQueryParameterType`` instance.
+    """
+
+    @classmethod
+    def _parse_range_element_type(self, type_):
+        """Helper method that parses the input range element type, which may
+        be a string, or a ScalarQueryParameterType object.
+
+        Returns:
+            google.cloud.bigquery.query.ScalarQueryParameterType: Instance
+        """
+        if isinstance(type_, str):
+            if type_ not in _RANGE_ELEMENT_TYPE_STR:
+                raise ValueError(
+                    "If given as a string, range element type must be one of "
+                    "'TIMESTAMP', 'DATE', or 'DATETIME'."
+                )
+            return ScalarQueryParameterType(type_)
+        elif isinstance(type_, ScalarQueryParameterType):
+            if type_._type not in _RANGE_ELEMENT_TYPE_STR:
+                raise ValueError(
+                    "If given as a ScalarQueryParameter object, range element "
+                    "type must be one of 'TIMESTAMP', 'DATE', or 'DATETIME' "
+                    "type."
+                )
+            return type_
+        else:
+            raise ValueError(
+                "range_type must be a string or ScalarQueryParameter object, "
+                "of 'TIMESTAMP', 'DATE', or 'DATETIME' type."
+            )
+
+    def __init__(self, type_, *, name=None, description=None):
+        self.type_ = self._parse_range_element_type(type_)
+        self.name = name
+        self.description = description
+
+    @classmethod
+    def from_api_repr(cls, resource):
+        """Factory: construct parameter type from JSON resource.
+
+        Args:
+            resource (Dict): JSON mapping of parameter
+
+        Returns:
+            google.cloud.bigquery.query.RangeQueryParameterType: Instance
+        """
+        type_ = resource["rangeElementType"]["type"]
+        name = resource.get("name")
+        description = resource.get("description")
+
+        return cls(type_, name=name, description=description)
+
+    def to_api_repr(self):
+        """Construct JSON API representation for the parameter type.
+
+        Returns:
+            Dict: JSON mapping
+        """
+        # Name and description are only used if the type is a field inside a struct
+        # type, but it's StructQueryParameterType's responsibilty to use these two
+        # attributes in the API representation when needed. Here we omit them.
+        return {
+            "type": "RANGE",
+            "rangeElementType": self.type_.to_api_repr(),
+        }
+
+    def with_name(self, new_name: Union[str, None]):
+        """Return a copy of the instance with ``name`` set to ``new_name``.
+
+        Args:
+            name (Union[str, None]):
+                The new name of the range query parameter type. If ``None``,
+                the existing name is cleared.
+
+        Returns:
+            google.cloud.bigquery.query.RangeQueryParameterType:
+               A new instance with updated name.
+        """
+        return type(self)(self.type_, name=new_name, description=self.description)
+
+    def __repr__(self):
+        name = f", name={self.name!r}" if self.name is not None else ""
+        description = (
+            f", description={self.description!r}"
+            if self.description is not None
+            else ""
+        )
+        return f"{self.__class__.__name__}({self.type_!r}{name}{description})"
+
+    def _key(self):
+        """A tuple key that uniquely describes this field.
+
+        Used to compute this instance's hashcode and evaluate equality.
+
+        Returns:
+            Tuple: The contents of this
+            :class:`~google.cloud.bigquery.query.RangeQueryParameterType`.
+        """
+        type_ = self.type_.to_api_repr()
+        return (self.name, type_, self.description)
+
+    def __eq__(self, other):
+        if not isinstance(other, RangeQueryParameterType):
+            return NotImplemented
+        return self._key() == other._key()
+
+    def __ne__(self, other):
+        return not self == other
+
+
 class _AbstractQueryParameter(object):
     """Base class for named / positional query parameters."""
 
@@ -811,6 +936,178 @@ class StructQueryParameter(_AbstractQueryParameter):
         return "StructQueryParameter{}".format(self._key())
 
 
+class RangeQueryParameter(_AbstractQueryParameter):
+    """Named / positional query parameters for range values.
+
+    Args:
+        range_element_type (Union[str, RangeQueryParameterType]):
+            The type of range elements. It must be one of 'TIMESTAMP',
+            'DATE', or 'DATETIME'.
+
+        start (Optional[Union[ScalarQueryParameter, str]]):
+            The start of the range value. Must be the same type as
+            range_element_type. If not provided, it's interpreted as UNBOUNDED.
+
+        end (Optional[Union[ScalarQueryParameter, str]]):
+            The end of the range value. Must be the same type as
+            range_element_type. If not provided, it's interpreted as UNBOUNDED.
+
+        name (Optional[str]):
+            Parameter name, used via ``@foo`` syntax.  If None, the
+            parameter can only be addressed via position (``?``).
+    """
+
+    @classmethod
+    def _parse_range_element_type(self, range_element_type):
+        if isinstance(range_element_type, str):
+            if range_element_type not in _RANGE_ELEMENT_TYPE_STR:
+                raise ValueError(
+                    "If given as a string, range_element_type must be one of "
+                    f"'TIMESTAMP', 'DATE', or 'DATETIME'. Got {range_element_type}."
+                )
+            return RangeQueryParameterType(range_element_type)
+        elif isinstance(range_element_type, RangeQueryParameterType):
+            if range_element_type.type_._type not in _RANGE_ELEMENT_TYPE_STR:
+                raise ValueError(
+                    "If given as a RangeQueryParameterType object, "
+                    "range_element_type must be one of 'TIMESTAMP', 'DATE', "
+                    "or 'DATETIME' type."
+                )
+            return range_element_type
+        else:
+            raise ValueError(
+                "range_element_type must be a string or "
+                "RangeQueryParameterType object, of 'TIMESTAMP', 'DATE', "
+                "or 'DATETIME' type. Got "
+                f"{type(range_element_type)}:{range_element_type}"
+            )
+
+    @classmethod
+    def _serialize_range_element_value(self, value, type_):
+        if value is None or isinstance(value, str):
+            return value
+        else:
+            converter = _SCALAR_VALUE_TO_JSON_PARAM.get(type_)
+            if converter is not None:
+                return converter(value)  # type: ignore
+            else:
+                raise ValueError(
+                    f"Cannot convert range element value from type {type_}, "
+                    "must be one of the strings 'TIMESTAMP', 'DATE' "
+                    "'DATETIME' or a RangeQueryParameterType object."
+                )
+
+    def __init__(
+        self,
+        range_element_type,
+        start=None,
+        end=None,
+        name=None,
+    ):
+        self.name = name
+        self.range_element_type = self._parse_range_element_type(range_element_type)
+        print(self.range_element_type.type_._type)
+        self.start = start
+        self.end = end
+
+    @classmethod
+    def positional(
+        cls, range_element_type, start=None, end=None
+    ) -> "RangeQueryParameter":
+        """Factory for positional parameters.
+
+        Args:
+            range_element_type (Union[str, RangeQueryParameterType]):
+                The type of range elements. It must be one of `'TIMESTAMP'`,
+                `'DATE'`, or `'DATETIME'`.
+
+            start (Optional[Union[ScalarQueryParameter, str]]):
+                The start of the range value. Must be the same type as
+                range_element_type. If not provided, it's interpreted as
+                UNBOUNDED.
+
+            end (Optional[Union[ScalarQueryParameter, str]]):
+                The end of the range value. Must be the same type as
+                range_element_type. If not provided, it's interpreted as
+                UNBOUNDED.
+
+        Returns:
+            google.cloud.bigquery.query.RangeQueryParameter: Instance without
+            name.
+        """
+        return cls(range_element_type, start, end)
+
+    @classmethod
+    def from_api_repr(cls, resource: dict) -> "RangeQueryParameter":
+        """Factory: construct parameter from JSON resource.
+
+        Args:
+            resource (Dict): JSON mapping of parameter
+
+        Returns:
+            google.cloud.bigquery.query.RangeQueryParameter: Instance
+        """
+        name = resource.get("name")
+        range_element_type = (
+            resource.get("parameterType", {}).get("rangeElementType", {}).get("type")
+        )
+        range_value = resource.get("parameterValue", {}).get("rangeValue", {})
+        start = range_value.get("start", {}).get("value")
+        end = range_value.get("end", {}).get("value")
+
+        return cls(range_element_type, start=start, end=end, name=name)
+
+    def to_api_repr(self) -> dict:
+        """Construct JSON API representation for the parameter.
+
+        Returns:
+            Dict: JSON mapping
+        """
+        range_element_type = self.range_element_type.to_api_repr()
+        type_ = self.range_element_type.type_._type
+        start = self._serialize_range_element_value(self.start, type_)
+        end = self._serialize_range_element_value(self.end, type_)
+        resource = {
+            "parameterType": range_element_type,
+            "parameterValue": {
+                "rangeValue": {
+                    "start": {"value": start},
+                    "end": {"value": end},
+                },
+            },
+        }
+
+        # distinguish between name not provided vs. name being empty string
+        if self.name is not None:
+            resource["name"] = self.name
+
+        return resource
+
+    def _key(self):
+        """A tuple key that uniquely describes this field.
+
+        Used to compute this instance's hashcode and evaluate equality.
+
+        Returns:
+            Tuple: The contents of this
+            :class:`~google.cloud.bigquery.query.RangeQueryParameter`.
+        """
+
+        range_element_type = self.range_element_type.to_api_repr()
+        return (self.name, range_element_type, self.start, self.end)
+
+    def __eq__(self, other):
+        if not isinstance(other, RangeQueryParameter):
+            return NotImplemented
+        return self._key() == other._key()
+
+    def __ne__(self, other):
+        return not self == other
+
+    def __repr__(self):
+        return "RangeQueryParameter{}".format(self._key())
+
+
 class SqlParameterScalarTypes:
     """Supported scalar SQL query parameter types as type objects."""
 

{google-cloud-bigquery-3.18.0 → google-cloud-bigquery-3.19.0}/google/cloud/bigquery/standard_sql.py

@@ -43,6 +43,7 @@ class StandardSqlDataType:
                 ]
             }
         }
+        RANGE: {type_kind="RANGE", range_element_type="DATETIME"}
 
     Args:
         type_kind:
@@ -52,6 +53,8 @@ class StandardSqlDataType:
             The type of the array's elements, if type_kind is ARRAY.
         struct_type:
             The fields of this struct, in order, if type_kind is STRUCT.
+        range_element_type:
+            The type of the range's elements, if type_kind is RANGE.
     """
 
     def __init__(
@@ -61,12 +64,14 @@ class StandardSqlDataType:
         ] = StandardSqlTypeNames.TYPE_KIND_UNSPECIFIED,
         array_element_type: Optional["StandardSqlDataType"] = None,
         struct_type: Optional["StandardSqlStructType"] = None,
+        range_element_type: Optional["StandardSqlDataType"] = None,
     ):
         self._properties: Dict[str, Any] = {}
 
         self.type_kind = type_kind
         self.array_element_type = array_element_type
         self.struct_type = struct_type
+        self.range_element_type = range_element_type
 
     @property
     def type_kind(self) -> Optional[StandardSqlTypeNames]:
@@ -127,6 +132,28 @@ class StandardSqlDataType:
         else:
             self._properties["structType"] = struct_type
 
+    @property
+    def range_element_type(self) -> Optional["StandardSqlDataType"]:
+        """The type of the range's elements, if type_kind = "RANGE". Must be
+        one of DATETIME, DATE, or TIMESTAMP."""
+        range_element_info = self._properties.get("rangeElementType")
+
+        if range_element_info is None:
+            return None
+
+        result = StandardSqlDataType()
+        result._properties = range_element_info  # We do not use a copy on purpose.
+        return result
+
+    @range_element_type.setter
+    def range_element_type(self, value: Optional["StandardSqlDataType"]):
+        range_element_type = None if value is None else value.to_api_repr()
+
+        if range_element_type is None:
+            self._properties.pop("rangeElementType", None)
+        else:
+            self._properties["rangeElementType"] = range_element_type
+
     def to_api_repr(self) -> Dict[str, Any]:
         """Construct the API resource representation of this SQL data type."""
         return copy.deepcopy(self._properties)
@@ -155,7 +182,13 @@ class StandardSqlDataType:
             if struct_info:
                 struct_type = StandardSqlStructType.from_api_repr(struct_info)
 
-        return cls(type_kind, array_element_type, struct_type)
+        range_element_type = None
+        if type_kind == StandardSqlTypeNames.RANGE:
+            range_element_info = resource.get("rangeElementType")
+            if range_element_info:
+                range_element_type = cls.from_api_repr(range_element_info)
+
+        return cls(type_kind, array_element_type, struct_type, range_element_type)
 
     def __eq__(self, other):
         if not isinstance(other, StandardSqlDataType):
@@ -165,6 +198,7 @@ class StandardSqlDataType:
                 self.type_kind == other.type_kind
                 and self.array_element_type == other.array_element_type
                 and self.struct_type == other.struct_type
+                and self.range_element_type == other.range_element_type
             )
 
     def __str__(self):

{google-cloud-bigquery-3.18.0 → google-cloud-bigquery-3.19.0}/google/cloud/bigquery/version.py

@@ -12,4 +12,4 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-__version__ = "3.18.0"
+__version__ = "3.19.0"

{google-cloud-bigquery-3.18.0 → google-cloud-bigquery-3.19.0/google_cloud_bigquery.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: google-cloud-bigquery
-Version: 3.18.0
+Version: 3.19.0
 Summary: Google BigQuery API client library
 Home-page: https://github.com/googleapis/python-bigquery
 Author: Google LLC
@@ -22,7 +22,8 @@ Classifier: Operating System :: OS Independent
 Classifier: Topic :: Internet
 Requires-Python: >=3.7
 License-File: LICENSE
-Requires-Dist: google-api-core!=2.0.*,!=2.1.*,!=2.2.*,!=2.3.0,<3.0.0dev,>=1.31.5
+Requires-Dist: google-api-core[grpc]!=2.0.*,!=2.1.*,!=2.10.*,!=2.2.*,!=2.3.*,!=2.4.*,!=2.5.*,!=2.6.*,!=2.7.*,!=2.8.*,!=2.9.*,<3.0.0dev,>=1.34.1
+Requires-Dist: google-auth<3.0.0dev,>=2.14.1
 Requires-Dist: google-cloud-core<3.0.0dev,>=1.6.0
 Requires-Dist: google-resumable-media<3.0dev,>=0.6.0
 Requires-Dist: packaging>=20.0.0

{google-cloud-bigquery-3.18.0 → google-cloud-bigquery-3.19.0}/google_cloud_bigquery.egg-info/requires.txt

@@ -1,4 +1,5 @@
-google-api-core!=2.0.*,!=2.1.*,!=2.2.*,!=2.3.0,<3.0.0dev,>=1.31.5
+google-api-core[grpc]!=2.0.*,!=2.1.*,!=2.10.*,!=2.2.*,!=2.3.*,!=2.4.*,!=2.5.*,!=2.6.*,!=2.7.*,!=2.8.*,!=2.9.*,<3.0.0dev,>=1.34.1
+google-auth<3.0.0dev,>=2.14.1
 google-cloud-core<3.0.0dev,>=1.6.0
 google-resumable-media<3.0dev,>=0.6.0
 packaging>=20.0.0

{google-cloud-bigquery-3.18.0 → google-cloud-bigquery-3.19.0}/setup.py

@@ -32,7 +32,8 @@ dependencies = [
     # NOTE: Maintainers, please do not require google-api-core>=2.x.x
     # Until this issue is closed
     # https://github.com/googleapis/google-cloud-python/issues/10566
-    "google-api-core >= 1.31.5, <3.0.0dev,!=2.0.*,!=2.1.*,!=2.2.*,!=2.3.0",
+    "google-api-core[grpc] >= 1.34.1, <3.0.0dev,!=2.0.*,!=2.1.*,!=2.2.*,!=2.3.*,!=2.4.*,!=2.5.*,!=2.6.*,!=2.7.*,!=2.8.*,!=2.9.*,!=2.10.*",
+    "google-auth >= 2.14.1, <3.0.0dev",
     # NOTE: Maintainers, please do not require google-cloud-core>=2.x.x
     # Until this issue is closed
     # https://github.com/googleapis/google-cloud-python/issues/10566

{google-cloud-bigquery-3.18.0 → google-cloud-bigquery-3.19.0}/tests/system/test_client.py

@@ -2193,6 +2193,44 @@ class TestBigQuery(unittest.TestCase):
         assert len(rows) == 1
         assert rows[0].max_value == 100.0
 
+    def test_create_routine_with_range(self):
+        routine_name = "routine_range"
+        dataset = self.temp_dataset(_make_dataset_id("routine_range"))
+
+        routine = bigquery.Routine(
+            dataset.routine(routine_name),
+            type_="SCALAR_FUNCTION",
+            language="SQL",
+            body="RANGE_START(x)",
+            arguments=[
+                bigquery.RoutineArgument(
+                    name="x",
+                    data_type=bigquery.StandardSqlDataType(
+                        type_kind=bigquery.StandardSqlTypeNames.RANGE,
+                        range_element_type=bigquery.StandardSqlDataType(
+                            type_kind=bigquery.StandardSqlTypeNames.DATE
+                        ),
+                    ),
+                )
+            ],
+            return_type=bigquery.StandardSqlDataType(
+                type_kind=bigquery.StandardSqlTypeNames.DATE
+            ),
+        )
+
+        query_string = (
+            "SELECT `{}`(RANGE<DATE> '[2016-08-12, UNBOUNDED)') as range_start;".format(
+                str(routine.reference)
+            )
+        )
+
+        routine = helpers.retry_403(Config.CLIENT.create_routine)(routine)
+        query_job = helpers.retry_403(Config.CLIENT.query)(query_string)
+        rows = list(query_job.result())
+
+        assert len(rows) == 1
+        assert rows[0].range_start == datetime.date(2016, 8, 12)
+
     def test_create_tvf_routine(self):
         from google.cloud.bigquery import (
             Routine,