diff --git a/src/base/name/dname.rs b/src/base/name/dname.rs
index 12f9eafa5..9610f4cab 100644
--- a/src/base/name/dname.rs
+++ b/src/base/name/dname.rs
@@ -7,6 +7,7 @@ use super::super::octets::{
 use super::super::octets::{DeserializeOctets, SerializeOctets};
 use super::builder::{DnameBuilder, FromStrError};
 use super::label::{Label, LabelTypeError, SplitLabelError};
+use super::parsed::ParsedDname;
 use super::relative::{DnameIter, RelativeDname};
 use super::traits::{ToDname, ToLabelIter};
 #[cfg(feature = "master")]
@@ -624,6 +625,17 @@ where
     }
 }
 
+impl<SrcOctets, Octets> OctetsFrom<ParsedDname<SrcOctets>> for Dname<Octets>
+where
+    SrcOctets: AsRef<[u8]>,
+    Octets: FromBuilder,
+    <Octets as FromBuilder>::Builder: EmptyBuilder,
+{
+    fn octets_from(source: ParsedDname<SrcOctets>) -> Result<Self, ShortBuf> {
+        source.to_dname().map_err(|_| ShortBuf)
+    }
+}
+
 //--- FromStr
 
 impl<Octets> FromStr for Dname<Octets>
diff --git a/src/base/octets.rs b/src/base/octets.rs
index e0255ed3e..28733a763 100644
--- a/src/base/octets.rs
+++ b/src/base/octets.rs
@@ -371,32 +371,16 @@ impl<'a, Source: AsRef<[u8]> + 'a> OctetsFrom<&'a Source> for &'a [u8] {
 }
 
 #[cfg(feature = "std")]
-impl<Source> OctetsFrom<Source> for Vec<u8>
-where
-    Self: From<Source>,
-{
-    fn octets_from(source: Source) -> Result<Self, ShortBuf> {
-        Ok(From::from(source))
+impl<'a> OctetsFrom<&'a [u8]> for Vec<u8> {
+    fn octets_from(source: &'a [u8]) -> Result<Self, ShortBuf> {
+        Ok(Self::from(source))
     }
 }
 
-#[cfg(feature = "bytes")]
-impl<Source> OctetsFrom<Source> for Bytes
-where
-    Self: From<Source>,
-{
-    fn octets_from(source: Source) -> Result<Self, ShortBuf> {
-        Ok(From::from(source))
-    }
-}
-
-#[cfg(feature = "bytes")]
-impl<Source> OctetsFrom<Source> for BytesMut
-where
-    Self: From<Source>,
-{
-    fn octets_from(source: Source) -> Result<Self, ShortBuf> {
-        Ok(From::from(source))
+#[cfg(feature = "std")]
+impl OctetsFrom<Vec<u8>> for Vec<u8> {
+    fn octets_from(source: Vec<u8>) -> Result<Self, ShortBuf> {
+        Ok(source)
     }
 }
 
@@ -411,6 +395,76 @@ where
     }
 }
 
+#[cfg(feature = "bytes")]
+impl<'a> OctetsFrom<&'a [u8]> for Bytes {
+    fn octets_from(source: &'a [u8]) -> Result<Self, ShortBuf> {
+        Ok(Self::copy_from_slice(source))
+    }
+}
+
+#[cfg(feature = "bytes")]
+impl OctetsFrom<Bytes> for Bytes {
+    fn octets_from(source: Bytes) -> Result<Self, ShortBuf> {
+        Ok(source)
+    }
+}
+
+#[cfg(feature = "bytes")]
+impl OctetsFrom<BytesMut> for BytesMut {
+    fn octets_from(source: BytesMut) -> Result<Self, ShortBuf> {
+        Ok(source)
+    }
+}
+
+#[cfg(feature = "bytes")]
+impl OctetsFrom<Bytes> for BytesMut {
+    fn octets_from(source: Bytes) -> Result<Self, ShortBuf> {
+        Ok(Self::from(source.as_ref()))
+    }
+}
+
+#[cfg(feature = "bytes")]
+impl OctetsFrom<BytesMut> for Bytes {
+    fn octets_from(source: BytesMut) -> Result<Self, ShortBuf> {
+        Ok(Self::from(source))
+    }
+}
+
+#[cfg(feature = "bytes")]
+impl<'a> OctetsFrom<&'a [u8]> for BytesMut {
+    fn octets_from(source: &'a [u8]) -> Result<Self, ShortBuf> {
+        Ok(Self::from(source))
+    }
+}
+
+#[cfg(feature = "bytes")]
+impl OctetsFrom<Vec<u8>> for Bytes {
+    fn octets_from(source: Vec<u8>) -> Result<Self, ShortBuf> {
+        Ok(Self::from(source))
+    }
+}
+
+#[cfg(feature = "bytes")]
+impl OctetsFrom<Vec<u8>> for BytesMut {
+    fn octets_from(source: Vec<u8>) -> Result<Self, ShortBuf> {
+        Ok(Self::from(source.as_slice()))
+    }
+}
+
+#[cfg(feature = "bytes")]
+impl OctetsFrom<Bytes> for Vec<u8> {
+    fn octets_from(source: Bytes) -> Result<Self, ShortBuf> {
+        Ok(source.as_ref().to_vec())
+    }
+}
+
+#[cfg(feature = "bytes")]
+impl OctetsFrom<BytesMut> for Vec<u8> {
+    fn octets_from(source: BytesMut) -> Result<Self, ShortBuf> {
+        Ok(source.as_ref().to_vec())
+    }
+}
+
 #[cfg(feature = "heapless")]
 impl<Source, const N: usize> OctetsFrom<Source> for heapless::Vec<u8, N>
 where
@@ -1884,6 +1938,41 @@ macro_rules! octets_array {
             }
         }
 
+        impl OctetsFrom<$name> for $name {
+            fn octets_from(source: $name) -> Result<Self, ShortBuf> {
+                Ok(source)
+            }
+        }
+
+        #[cfg(feature = "std")]
+        impl OctetsFrom<Vec<u8>> for $name {
+            fn octets_from(source: Vec<u8>) -> Result<Self, ShortBuf> {
+                let octets = <[u8; $len]>::try_from(source).map_err(|_| ShortBuf)?;
+                Ok($name { octets, len: $len })
+            }
+        }
+
+        #[cfg(feature = "std")]
+        impl OctetsFrom<$name> for Vec<u8> {
+            fn octets_from(source: $name) -> Result<Self, ShortBuf> {
+                Ok(source.octets.into())
+            }
+        }
+
+        #[cfg(feature = "bytes")]
+        impl OctetsFrom<$name> for Bytes {
+            fn octets_from(source: $name) -> Result<Self, ShortBuf> {
+                Ok(source.octets.to_vec().into())
+            }
+        }
+
+        #[cfg(feature = "bytes")]
+        impl OctetsFrom<$name> for BytesMut {
+            fn octets_from(source: $name) -> Result<Self, ShortBuf> {
+                Ok(BytesMut::from(source.octets.as_ref()))
+            }
+        }
+
         impl core::ops::Deref for $name {
             type Target = [u8];
 
@@ -2260,4 +2349,61 @@ mod test {
         assert_eq!(parser.parse_u32(), Ok(0xfd78a84e));
         assert_eq!(parser.parse_u32(), Err(ParseError::ShortInput));
     }
+
+    #[cfg(feature = "std")]
+    #[test]
+    fn convert() {
+        use crate::base::octets::{Octets32, OctetsInto};
+        use crate::base::{Dname, Record};
+        use crate::rdata::Cname;
+
+        // Use case: provide a flexible interface for caller to
+        // get record from storage.
+        fn load_record<O>() -> Record<Dname<O>, Cname<Dname<O>>>
+        where
+            O: FromBuilder + OctetsFrom<Octets32>,
+            <O as FromBuilder>::Builder: EmptyBuilder,
+        {
+            // let rr = cache_get().clone();
+            let rr: Record<Dname<Octets32>, Cname<Dname<Octets32>>> = (
+                "a.example".parse().unwrap(),
+                300,
+                Cname::new("b.example".parse().unwrap()),
+            )
+                .into();
+
+            rr.octets_into().unwrap()
+        }
+        let rr: Record<Dname<Vec<u8>>, Cname<Dname<Vec<u8>>>> = load_record();
+
+        let rr_ref: Record<_, _> = (
+            rr.owner().for_slice(),
+            rr.ttl(),
+            Cname::new(rr.data().cname().for_slice()),
+        )
+            .into();
+
+        // Use case: save a owned copy into cache.
+        fn save_record<O>(rr: Record<Dname<O>, Cname<Dname<O>>>)
+        where
+            O: AsRef<[u8]>,
+            Vec<u8>: OctetsFrom<O>,
+        {
+            let _owned: Record<Dname<Vec<u8>>, Cname<Dname<Vec<u8>>>> =
+                rr.octets_into().unwrap();
+            // cache_put(_owned)
+        }
+        save_record(rr_ref.clone());
+
+        // convert between octets
+        #[cfg(feature = "bytes")]
+        {
+            use bytes::Bytes;
+
+            let b: Record<Dname<Bytes>, Cname<Dname<Bytes>>> =
+                rr_ref.clone().octets_into().unwrap();
+            let _: Record<Dname<Vec<u8>>, Cname<Dname<Vec<u8>>>> =
+                b.octets_into().unwrap();
+        }
+    }
 }
diff --git a/src/base/record.rs b/src/base/record.rs
index 90ee5b307..a772908ee 100644
--- a/src/base/record.rs
+++ b/src/base/record.rs
@@ -1007,22 +1007,24 @@ impl<N, D> From<ShortBuf> for RecordParseError<N, D> {
 mod test {
 
     #[test]
-    #[cfg(features = "bytes")]
+    #[cfg(feature = "bytes")]
     fn ds_octets_into() {
-        use crate::base::iana::{DigestAlg, Rtype, SecAlg};
-        use crate::name::Dname;
-        use crate::octets::OctetsInto;
+        use crate::base::iana::{Class, DigestAlg, SecAlg};
+        use crate::base::octets::OctetsInto;
+        use crate::base::{Dname, Record};
         use crate::rdata::Ds;
+        use bytes::Bytes;
 
+        let owner = "a.example".parse::<Dname<Bytes>>().unwrap();
         let ds: Record<Dname<&[u8]>, Ds<&[u8]>> = Record::new(
-            "a.example".parse().unwrap(),
+            owner.for_slice(),
             Class::In,
             86400,
-            Ds::new(12, SecAlg::RsaSha256, b"something"),
+            Ds::new(12, SecAlg::RsaSha256, DigestAlg::Sha256, b"something"),
         );
         let ds_bytes: Record<Dname<Bytes>, Ds<Bytes>> =
-            ds.octets_into().unwrap();
+            ds.clone().octets_into().unwrap();
         assert_eq!(ds.owner(), ds_bytes.owner());
-        asswer_eq!(ds.data().digest(), ds_bytes.data().digest());
+        assert_eq!(ds.data().digest(), ds_bytes.data().digest());
     }
 }
diff --git a/src/rdata/rfc1035.rs b/src/rdata/rfc1035.rs
index afcfe90fe..5e987fda2 100644
--- a/src/rdata/rfc1035.rs
+++ b/src/rdata/rfc1035.rs
@@ -1841,29 +1841,30 @@ mod test {
     use std::vec::Vec;
 
     #[test]
-    #[cfg(features = "bytes")]
+    #[cfg(feature = "bytes")]
     fn hinfo_octets_into() {
-        use crate::octets::OctetsInto;
+        use crate::base::octets::OctetsInto;
 
         let hinfo: Hinfo<Vec<u8>> =
             Hinfo::new("1234".parse().unwrap(), "abcd".parse().unwrap());
-        let hinfo_bytes: Hinfo<bytes::Bytes> = hinfo.octets_into().unwrap();
+        let hinfo_bytes: Hinfo<bytes::Bytes> =
+            hinfo.clone().octets_into().unwrap();
         assert_eq!(hinfo.cpu(), hinfo_bytes.cpu());
         assert_eq!(hinfo.os(), hinfo_bytes.os());
     }
 
     #[test]
-    #[cfg(features = "bytes")]
+    #[cfg(feature = "bytes")]
     fn minfo_octets_into() {
+        use crate::base::octets::OctetsInto;
         use crate::base::Dname;
-        use crate::octets::OctetsInto;
 
         let minfo: Minfo<Dname<Vec<u8>>> = Minfo::new(
             "a.example".parse().unwrap(),
             "b.example".parse().unwrap(),
         );
         let minfo_bytes: Minfo<Dname<bytes::Bytes>> =
-            minfo.octets_into().unwrap();
+            minfo.clone().octets_into().unwrap();
         assert_eq!(minfo.rmailbx(), minfo_bytes.rmailbx());
         assert_eq!(minfo.emailbx(), minfo_bytes.emailbx());
     }