Method decode

src/expr/src/scalar/func/encoding.rs:114–166

(&self, s: &str)

    }

    fn decode(&self, s: &str) -> Result<Vec<u8>, EvalError> {
        // Process input in chunks of four bytes, after filtering out any bytes
        // that represent whitespace. Each byte is decoded into a sextet
        // according to the reverse charset mapping maintained in
        // `Self::decode_sextet`. The four sextets are converted to three octets
        // and emitted.
        //
        // When the last character in a chunk is `=` or the last two characters
        // in a chunk are both `=`, the chunk is missing its last one or two
        // sextets, respectively. Octets that are entirely determined by missing
        // sextets are elided. Octets that are partially determined by a missing
        // sextet assume the sextet was zero.
        //
        // It is an error for a `=` character to appear in another position in
        // a chunk. It is also an error if a chunk is incomplete.

        let mut buf = vec![];
        let mut bytes = s
            .as_bytes()
            .iter()
            .copied()
            .filter(|ch| !matches!(ch, b' ' | b'\t' | b'\n' | b'\r'));
        loop {
            match (bytes.next(), bytes.next(), bytes.next(), bytes.next()) {
                (Some(c1), Some(c2), Some(b'='), Some(b'=')) => {
                    let s1 = Self::decode_sextet(c1)?;
                    let s2 = Self::decode_sextet(c2)?;
                    buf.push((s1 << 2) | ((s2 & 0b110000) >> 4));
                }
                (Some(c1), Some(c2), Some(c3), Some(b'=')) => {
                    let s1 = Self::decode_sextet(c1)?;
                    let s2 = Self::decode_sextet(c2)?;
                    let s3 = Self::decode_sextet(c3)?;
                    buf.push((s1 << 2) | ((s2 & 0b110000) >> 4));
                    buf.push(((s2 & 0b001111) << 4) | ((s3 & 0b111100) >> 2));
                }
                (Some(b'='), _, _, _) | (_, Some(b'='), _, _) | (_, _, Some(b'='), _) => {
                    return Err(EvalError::InvalidBase64Equals);
                }
                (Some(c1), Some(c2), Some(c3), Some(c4)) => {
                    let s1 = Self::decode_sextet(c1)?;
                    let s2 = Self::decode_sextet(c2)?;
                    let s3 = Self::decode_sextet(c3)?;
                    let s4 = Self::decode_sextet(c4)?;
                    buf.push((s1 << 2) | ((s2 & 0b110000) >> 4));
                    buf.push(((s2 & 0b001111) << 4) | ((s3 & 0b111100) >> 2));
                    buf.push(((s3 & 0b000011) << 6) | s4);
                }
                (None, None, None, None) => return Ok(buf),
                _ => return Err(EvalError::InvalidBase64EndSequence),
            }
        }
    }
}

struct EscapeFormat;