kylebarron commented on code in PR #5822:
URL: https://github.com/apache/arrow-rs/pull/5822#discussion_r2080387205
##########
arrow-schema/src/field.rs:
##########
@@ -350,6 +355,167 @@ impl Field {
self
}
+ /// Returns the extension type name of this [`Field`], if set.
+ ///
+ /// This returns the value of [`EXTENSION_TYPE_NAME_KEY`], if set in
+ /// [`Field::metadata`]. If the key is missing, there is no extension type
+ /// name and this returns `None`.
+ ///
+ /// # Example
+ ///
+ /// ```
+ /// # use arrow_schema::{DataType, extension::EXTENSION_TYPE_NAME_KEY,
Field};
+ ///
+ /// let field = Field::new("", DataType::Null, false);
+ /// assert_eq!(field.extension_type_name(), None);
+ ///
+ /// let field = Field::new("", DataType::Null, false).with_metadata(
+ /// [(EXTENSION_TYPE_NAME_KEY.to_owned(), "example".to_owned())]
+ /// .into_iter()
+ /// .collect(),
+ /// );
+ /// assert_eq!(field.extension_type_name(), Some("example"));
+ /// ```
+ pub fn extension_type_name(&self) -> Option<&str> {
+ self.metadata()
+ .get(EXTENSION_TYPE_NAME_KEY)
+ .map(String::as_ref)
+ }
+
+ /// Returns the extension type metadata of this [`Field`], if set.
+ ///
+ /// This returns the value of [`EXTENSION_TYPE_METADATA_KEY`], if set in
+ /// [`Field::metadata`]. If the key is missing, there is no extension type
+ /// metadata and this returns `None`.
+ ///
+ /// # Example
+ ///
+ /// ```
+ /// # use arrow_schema::{DataType, extension::EXTENSION_TYPE_METADATA_KEY,
Field};
+ ///
+ /// let field = Field::new("", DataType::Null, false);
+ /// assert_eq!(field.extension_type_metadata(), None);
+ ///
+ /// let field = Field::new("", DataType::Null, false).with_metadata(
+ /// [(EXTENSION_TYPE_METADATA_KEY.to_owned(), "example".to_owned())]
+ /// .into_iter()
+ /// .collect(),
+ /// );
+ /// assert_eq!(field.extension_type_metadata(), Some("example"));
+ /// ```
+ pub fn extension_type_metadata(&self) -> Option<&str> {
+ self.metadata()
+ .get(EXTENSION_TYPE_METADATA_KEY)
+ .map(String::as_ref)
+ }
+
+ /// Returns an instance of the given [`ExtensionType`] of this [`Field`],
+ /// if set in the [`Field::metadata`].
+ ///
+ /// # Error
+ ///
+ /// Returns an error if
+ /// - this field does not have the name of this extension type
+ /// ([`ExtensionType::NAME`]) in the [`Field::metadata`] (mismatch or
+ /// missing)
+ /// - the deserialization of the metadata
+ /// ([`ExtensionType::deserialize_metadata`]) fails
+ /// - the construction of the extension type ([`ExtensionType::try_new`])
+ /// fail (for example when the [`Field::data_type`] is not supported by
+ /// the extension type ([`ExtensionType::supports_data_type`]))
+ pub fn try_extension_type<E: ExtensionType>(&self) -> Result<E,
ArrowError> {
+ // Check the extension name in the metadata
+ match self.extension_type_name() {
+ // It should match the name of the given extension type
+ Some(name) if name == E::NAME => {
+ // Deserialize the metadata and try to construct the extension
+ // type
+ E::deserialize_metadata(self.extension_type_metadata())
+ .and_then(|metadata| E::try_new(self.data_type(),
metadata))
+ }
+ // Name mismatch
+ Some(name) => Err(ArrowError::InvalidArgumentError(format!(
+ "Field extension type name mismatch, expected {}, found
{name}",
+ E::NAME
+ ))),
+ // Name missing
+ None => Err(ArrowError::InvalidArgumentError(
+ "Field extension type name missing".to_owned(),
+ )),
+ }
+ }
+
+ /// Returns an instance of the given [`ExtensionType`] of this [`Field`],
+ /// panics if this [`Field`] does not have this extension type.
+ ///
+ /// # Panic
+ ///
+ /// This calls [`Field::try_extension_type`] and panics when it returns an
+ /// error.
+ pub fn extension_type<E: ExtensionType>(&self) -> E {
+ self.try_extension_type::<E>()
+ .unwrap_or_else(|e| panic!("{e}"))
+ }
+
+ /// Updates the metadata of this [`Field`] with the [`ExtensionType::NAME`]
+ /// and [`ExtensionType::metadata`] of the given [`ExtensionType`], if the
+ /// given extension type supports the [`Field::data_type`] of this field
+ /// ([`ExtensionType::supports_data_type`]).
+ ///
+ /// If the given extension type defines no metadata, a previously set
+ /// value of [`EXTENSION_TYPE_METADATA_KEY`] is cleared.
+ ///
+ /// # Error
+ ///
+ /// This functions returns an error if the data type of this field does not
+ /// match any of the supported storage types of the given extension type.
+ pub fn try_with_extension_type<E: ExtensionType>(
+ &mut self,
+ extension_type: E,
+ ) -> Result<(), ArrowError> {
+ // Make sure the data type of this field is supported
+ extension_type.supports_data_type(&self.data_type)?;
+
+ self.metadata
+ .insert(EXTENSION_TYPE_NAME_KEY.to_owned(), E::NAME.to_owned());
+ match extension_type.serialize_metadata() {
+ Some(metadata) => self
+ .metadata
+ .insert(EXTENSION_TYPE_METADATA_KEY.to_owned(), metadata),
+ // If this extension type has no metadata, we make sure to
+ // clear previously set metadata.
+ None => self.metadata.remove(EXTENSION_TYPE_METADATA_KEY),
+ };
+
+ Ok(())
+ }
+
+ /// Updates the metadata of this [`Field`] with the [`ExtensionType::NAME`]
+ /// and [`ExtensionType::metadata`] of the given [`ExtensionType`].
+ ///
+ /// # Panics
+ ///
+ /// This calls [`Field::try_with_extension_type`] and panics when it
+ /// returns an error.
+ pub fn with_extension_type<E: ExtensionType>(mut self, extension_type: E)
-> Self {
Review Comment:
I suppose that makes sense!
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: [email protected]
For queries about this service, please contact Infrastructure at:
[email protected]
